@חוקר סליחה על האיחור... זה היה קצת מסובך גם לי...

const { getEmbeddingLevels, getReorderSegments, getMirroredCharacter } = require("bidi-js")()

const str = 'ימין hashem (עושה) חיל'

function logical2visual(str) {
    const embeddingLevels = getEmbeddingLevels(str, 'rtl')
    const arr = str.split('').map((c, i) => embeddingLevels.levels[i] & 1 ? getMirroredCharacter(c) || c : c)
    for (const [start, end] of getReorderSegments(str, embeddingLevels)) {
        const tempArr = arr.slice(start, end + 1)
        tempArr.reverse()
        for (let i = start; i <= end; i++) {
            arr[i] = tempArr[i - start]
        }
    }
    return arr.join('')
}

logical2visual(str) // "ליח (השוע) hashem ןימי"

נראה לי שזה מושלם (עובד גם על משפט משולב של עברית ערבית וסינית, מספרים ותווים מיוחדים)
אם יש טקסט שגולש לכמה שורות, צריך קודם לחלק לשורות, ואז להריץ בנפרד לכל שורה

https://runkit.com/yossizahn/bidi-js

תגובה: תרגיל מתמטי של הסתרת מזהה רץ

בהמשך לנושא הנ"ל,

@dovid אמר בתרגיל מתמטי של הסתרת מזהה רץ:

הנה XOR למספרים עוקבים על מספר רנדומלי:
159866
159865
159864
159871
159870
159869
159868
159859
159858
159857

@dovid אמר בתרגיל מתמטי של הסתרת מזהה רץ:

אגב הרשימה של הXOR הינה אתגר הרבה יותר קל והוא לא הדליק פה מישהו ככל הנראה.

אדרבה, זה הדליק אותי מאוד,
(אמנם רק ביום שישי התחלתי לחשוב על זה ברצינות)

אפשר לחלק את האתגר לשנים:

• חילוץ המפתח מתוך מספרים עוקבים
• מתוך מספרים ממוינים, אבל לא בהכרח עוקבים

(עוד שאלה, האם אפשר לזהות אם המספרים עוקבים או לא? ספויילר... כן, בקלות)

הנה פתרון לחלק הראשון (מספרים עוקבים) ב-JS:

function makeRand (max) {
  return Math.floor(Math.random() * max)
}

function makeRange (start, length) {
  const ret = []
  for (i = 0; i < length; i++) {
    ret.push(start + i)
  }
  return ret;
}

function makeBitmask(width) {
  return width && -1 >>> 32 - width;
}

const KEY = makeRand(1000)

const nums = makeRange(makeRand(1000), 60)

// console.log('Numbers:', nums)

function extractXORKeySeq (numList) {
  let bestDiff, bestIndex
  bestDiff = bestIndex = -1
   
  for (let i = 1; i < numList.length; i++) {
    const diff = numList[i] ^ numList[i-1]
    if (diff & (diff + 1)) {
      throw new Error('Numbers are not sequential!')
    }
    if (diff > bestDiff) {
      bestDiff = diff
      bestIndex = i
    }
  }
   
  const previous = numList[bestIndex - 1]
  const extractLen = bestDiff.toString(2).length
  const keyBits = bestDiff ^ (previous ^ (1 << (extractLen - 1))) & makeBitmask(extractLen)

  return [extractLen, keyBits]
}

const [len, bits] = extractXORKeySeq(nums.map(i => i ^ KEY))

console.log(`Extracted last ${len} bits of the key: ${bits.toString(2).padStart(len, '0')}`)
console.log(`Real key is: ${KEY} (${KEY.toString(2)})`)
// console.log(`numList after decryption: ${nums.map(i => i ^ KEY).map(i => i ^ bits)}`)
console.assert(KEY.toString(2).padStart(32, '0').endsWith(bits.toString(2).padStart(len, '0')))

נ.ב. אשאיר פה את הקוד בלי הסבר לבינתיים למי שירצה להתעמק לבד...
מחר או מחרתיים יבוא ההסבר בל"נ
לענ"ד יותר קל למצוא את הפתרון באמצעות מחשבה מאשר לנסות לעקוב אחרי הקוד הזה...

עריכה: יש חסרון בקוד. אני מחלץ פחות ביטים מהמקסימום התיאורטי. אתקן בהזדמנות

עדכון: הקוד תוקן סופית. זה אמור להיות מושלם עכשיו

תשובה יותר בכיוון האנושי ופחות בכיוון הטכני:
אנשים ששואלים שאלות כל אבטחת השרת, על פי רוב לא מבינים באבטחה, וחלק מהם חושבים שהם מבינים והם הכי גרועים. הם בד"כ אנשים שבאו לעולם עם התפקיד היחיד של לעצבן מפתחים רציניים שרק רוצים לחיות את החיים שלהם בשלווה...
צריך לענות עם מילים בומבסטיות שגם אתה וגם הם לא מבינים מה הם אומרים. ועם בטחון עצמי מוגזם.

מישהו באמת צריך ליצור מילון של מונחים מפציצים לדברים רגילים לגמרי
למשל:

firewall = advanced perimeter defense mechanism

נו, מישהו מתנדב למשימה?

לגבי השוואה בין הפריימוורקים:

אני מסכים לדברי @מוטי-אורן ש-VUE זה הכי קל.
התרשמותי מהאחרים:

• בריאקט יש יותר מכשולים, ויותר קשה להבין את המודל ולהשתמש בו בצורה נכונה.
• אנגולר הוא הרבה יותר ממה שתיארתי למעלה. הוא נותן לך הכל, ויש לו דיעה איך לממש את הכל, מקליינט HTTP ועד לטסטים,
• ב-angularjs לא לגעת למרות מה שדוד יטען.

@צדיק-תמים אמר באיזה ספרייה/פריימוורק (מה זה בכלל, בעצם?...) מומלץ ללמוד כיום?:

בכלל אמר לי (בפרטי) ללכת על NPM

הדברים לא מובנים (אולי הוצאו חוץ מהקשרם). NPM לא מקביל בכלל לריאקט ויו ואנגולר. זה מטפל בנושא אחר לגמרי.

לגבי תיעוד בעברית, זה באמת בעיה, אני מצטער, אבל אין לי כל כך איך לעזור...

@יושב-אוהלים
א) אתה כן משתמש בתוסף שלי, זה שמישהו העתיק את הקוד לא הופך את זה לשלו...
ב) אתה מאשים אותי במשהו לא נכון, אני מכיר את זה שערך את הקוד וכמובן שבדקתי את השינויים שלו וראיתי כל מה ששונה (הוא סה"כ שינה את ברירות המחדל, לא צפיתי שאף אחד ישתמש בברירות המחדל), וגם (כמו שציינת) במצב הנוכחי זה באמת שומה על מנהל הפורום להבין טיפה את הקוד לפני השימוש.

בכל מקרה, אני שומע ממך שהקוד לא מתאים לגירסת נודביבי החדש. אם יהיה לי זמן וחשק אבדוק בל"נ.

@רפאל נראה לי שהספרייה הנ"ל לא מעשית בשביל ר' @אבי-203 כי הוא כלוא בארגז החול של WIX (השי"ת יוצאנו מאפילה לאורה במהירה אכי"ר...)

@שמואל4 אמר בעזרה| תקשור בapi בשפת הphp לפלטפורמת nodebb:

במידה שזה יעבוד

אני מנסה בד"כ לא לכתוב דברים בלי לבדוק מקודם שזה עובד...

@שאול-נ-י ידידי...

אדם שרוצה להתעסק בתכנות חייב להיות מרובע.
לא סתם מרובע אלא עם פינות קוצניות שדוקרים לכל מי שנוגע.
יותר מרובע מריבוע.

למה?
כי המחשב מרובע.
המחשב יותר מרובע מריבוע.
כמו הגולם המיתלוגי, המחשב עושה בדיוק מה שביקשנו ממנו. לא פחות ולא יותר.
כמו היקי הכי מעצבן ביקום. (מחילה מכל היקים...).

כחלק ממרובעות הזאת אתה חייב לדייק בתכלית הדיוק בכל מה שנוגע למחשבים. הם לא סלחניים בקיצוניות.

תדמיין לעצמך שיש לך חבר שהוא יקי מעצבן כזה. האם היית מעז לדבר איתו רמזים וחצאי משפטים???

אחרי ההקדמה אני רוצה להסביר לך שכאשר אני קורא שאלה בנושא תכנות אני קורא את השאלה כמו מחשב.
כתבת:

עכשיו אני מנסה לשלוח מחרוזת שיש בה ירידת שורה באמצע, והוא לא נותן לי ככה %0D%0A וגם לא כך n/

ניסיתי לענות על זה לפי איך שהבנתי את השאלה. טעיתי בהבנת השאלה. הייתי אמור לנחש מה זה "מנסה לשלוח"? לאן? איך? "והוא לא נותן לי". מי זה ה"הוא"? "ככה %0D%0A וגם לא כך n/" כלומר שניסית ככה? או שה"הוא" לא נותן לך את ה"ככה"?

גם ההבהרה שאתה מוסיף בפוסט השני לא מספיקה.

לא מספיק לכתוב מה השגיאה.
כדי ששום בר דעת יהיה מוכן לענות על השאלה בלי להסתכן בניחושים מיותרים וגוזלי זמן, הוא חייב לקבל פרטים מלאים עד כמה שידך מגעת.
שזה אומר:

• בדיוק מה עשית
• מה צפית שיקרה
• מה קרה בפועל

וכל הנ"ל בכתיבה ברורה שלא משתמעת לשתי פנים

השאלות הכי טובות הם אלו שכוללים קוד קצר וקולע שמדגים את הבעיה.

(אגב, בנוסף, חוץ ממה שאתה חייב לכתוב את כל מה שקשור לנושא, יש גם דרישה לא לכתוב שום דבר מעבר למה שקשור.
הדרישה של "לא שום דבר מעבר" הוא כמעט באותה רמת חשיבות כמעט כמו הדרישה לכתוב את כל הפרטים.
חייבים להפשיט את השאלה מכל המסביב שלא קשור לענין.
האמת היא שאם היית קונה לעצמך את היכולת הזאת לדייק כל כך בשאלות שלך, לכאורה היית מגיע לתשובות בכוחות עצמך. כי היית מצליח למקד בדיוק איפה הבעיה.)

@אבי ההשוואה לא כל כך הוגנת. המוצרים של גוגל נרצחו. של מייקרוסופט מתו מזקנה.

@מי-זה אמר בעזרה - הפעלת פקודה בשרת:

אני ניסיתי ועדיין מנסה כל הזמן ללמוד ממדריכים איך לעשות כזה דבר, אבל לא הולך לי

הבעיה שאתה יותר מדי ממוקד ביעד. אתה מנסה לקפוץ ממצב של אי ידיעה כמעט טוטאלית למצב של יכולת לכתוב קוד JS.

אין לי חשק לעזור ככה, ואני גם לא חושב שזה בהכרח לטובתך. (כן, לאחרונה נהייתי יותר עצבני. כנראה אני מזדקן...).
אבל אשמח לעזור לך בהכוונה איך ללכת שלב שלב בצורה מסודרת עד שתדע כבר את התשובה לשאלתך.

אם תרצה תגיד. אם לא - חכה למישהו עם יותר סבלנות...

@ivrtikshoret זה לא יעזור. אם תמצא דרך לעשות את מבוקשך אז א) אתה מחונן, תעשה לעצמך קריירה באבטחת מידע. ב) תדווח לגוגל - תקבל מהם פרס כספי גבוה.

@מעלה-ומוריד אולי עם קצת מאמץ קבוצתי יוכלו חברי תחומים התותחים למצוא לך פתרון מצויין שתשאיר את חשבון הבנק שלך מעל קו האדום התחתון...

ההתחלה:

• תוכנת pdftotext (הורדה). מריצים את זה ככה:

pdftotext -enc UTF-8 -layout source-file.pdf -

הנה קבלנו את התוכן של ה-pdf ל-stdout. (הסברים מה זה stdout במדריך שורת הפקודה שלי...)

• שלב הבא, נמצא regex ששולף את הטקסט הרצוי

• נרכיב פקודה שעושה שינוי השם לפי התוצאה של הפקודות הנ"ל.

לפני שנתחיל, בא נחליט באיזה שפה נכתוב את זה?

לכאורה powershell, למישהו יש הצעה טובה יותר?

@יוסף-בן-שמעון אמר בשני סקריפטים JS שמתנגשים:

אז אחד מהם דורס את השני.
מה שאפשר לעשות, שהפונקציה האנונימית תקרא לשני הפונקציות הנ"ל

אפשר גם (מומלץ) להשתמש ב-addEventListener שלא דורס.

window.addEventListener('scroll', myFunction);

אגב, זה מיותר לעטוף את הפונקציה בעוד פונקציה:

window.onscroll = function() {myFunction()};

כותבים פשוט:

window.onscroll = myFunction;

מתכון

מצרכים

הכרת שפת אנגלית... רצון להבין, חיפושי גוגל, עקשנות, חשיבה ביקורתית, זיקה מולדת לנושאים טכניים, זמן

הכנה

מערבלים היטב כ-10+ שנים

@nigun אמר במה זה ט'רד (thread)?:

יש את התהליך הראשי הנקרא Process
שזה בעצם מידע שנשמר בכתובת בזיכרון על הפעולה

תהליך הוא הרבה יותר מרק "מידע בזכרון". (כמו שלא היית מגדיר "מתכנת" כ"גוש בשר"...) אני מתקשה להגדיר בעברית מה זה תהליך. אבל זה ישות אבסטרקטי שמאופיין על ידי מקבץ של כמה דברים שהבולטים מביניהם הוא לפחות "קונטקסט ריצה" אחד (thread בלע"ז), מרחב זיכרון פרטי, ו"תור" אצל המעבד.

יש הבדל השקפתי יסודי בין לינוקס לווינדוס בנושא הגדרתו של "תהליך". בווינדוס התהליך הוא ישות אבסטרקטי לעצמו שכולל בתוכו לפחות thread אחד, אבל התהליך הוא לא ה-thread בעצמו אלא הבעלים שלו. בלינוקס אין שום הבדל בין תהליך ל-thread. thread הוא רק מופע מיוחד של תהליך שמשתף כמה ממאפייניו עם תהליכים/threads אחרים. (כאן מופיע rant אופייני של לינוס טורבלדס בנושא)
דוגמה קונקרטית להבדל הוא שבווינדוס גם תהליך בעל thread אחד יש לו 2 מזהים - מזהה התהליך - PID ומזהה ה-thread - ‏TID. לעומת זאת בלינוקס יש רק מזהה אחד, ה-PID.

כדי להבין לאשורו את הענין של threads וההבדל בין thread לתהליך, כדאי להכיר את הענין של מיפוי ובידוד הזכרון המכונה virtual memory בלע"ז.

מרחב הזכרון הפיזי של המחשב הוא ה-RAM. אם יש לך 2 ג"ב של ראם אז מרחב הזכרון הפיזי משתרע על פני הכתובות מ-0 עד 1073741823. ה-CPU יכול לגשת לכל בייט ממרחב זיכרון זה.

בימים הקסומים של DOS היו תהליכים ניגשים ישירות לכתובות ב-RAM.

זה מודל בעייתי ביותר כאשר יש ריבוי תהליכים (ב-DOS לא היו ריבוי תהליכים במובן הרגיל).

א. זה מחייב כל תהליך לשמור על עצמו מלדרוס על הרגליים של השני. דהיינו לבדוק איזה כתובות תפוסות על ידי תהליכים אחרים ולא לגעת בהם.
ב. תהליך זדוני יכול בזדון לגשת לזכרון של השני

כדי לאפשר את עניין ריבוי התהליכים בנוחות ובביטחון, הוחלט שבמצב רגיל ה-CPU לא ניגש ישר לכתובת זכרון בראם אלא כל גישה לזיכרון עובר תהליך מיפוי מכתובת ווירטואלי לכתובת פיזי. זה מאפשר בידוד תהליכים.

היתרון בזה הוא שבמקום שכל תהליך יצטרך לשמור על עצמו מלדרוס על הרגליים של השני, מערכת ההפעלה פשוט יגדיר עבור התהליך מפה שבו יש לו גישה לכל מרחב הזכרון האפשרי שה-CPU תומך בו (לא משנה כמה RAM באמת יש), ומאחורי הקלעים זה ימופה לכתובות פיזיות בצורה בטוחה שתהליך לא יכול לגשת לזכרון של תהליך שני. (אני מקצר קצת בתיאור של כל הפרטים של virtual memory ו-memory protection).

האמת היא שלמרות שלתהליך יש גישה לכל מרחב הזכרון, אבל בפועל זה מחולק ל-2 חלקים. חלק א זמין למתכנת וזה נקרא user space והחלק השני לא זמין למתכנת אלא למערכת ההפעלה (שפועל עבור התהליך בתוך ה-execution context של התהליך). זה ה-kernel space. החלק של ה-user space מבודד לכל תהליך בפני עצמו, כלומר מערכת ההפעלה ממפה את הכתובות לכל תהליך לאיזור נפרד של הראם הפיזי. החלק של הקרנל הוא אותו דבר לכל תהליך, כלומר זה ממופה על ידי מערכת ההפעלה לאותם כתובות פיזיות לכל תהליך.

לאור הנ"ל אכתוב את יתר הערותי:

הוא מכיל מידע כמו הID של התהליך ,העדיפות של התהליך ,ואת כל הפקודות ששייכות לתהליך ועוד

הדברים האלו לא מאוחסנים באותו מרחב זיכרון. ה-ID ושאר המטה דאטה שקשורים לתהליך מנוהלים לגמרי על ידי מערכת ההפעלה וזה נשמר במבנה בתוך מרחב הזכרון של הקרנל, הגישה אליו למתכנת הוא רק דרך ממשקים שמערכת ההפעלה מספקת (system calls בלע"ז).
בשונה מה"פקודות ששייכות לתהליך" (כלומר הקוד - הבינארי, לא קוד המקור - של התהליך) שזה ממופה לאיזור היוזר של התהליך.

והמעבד עובר על הפקודות שורה אחרי שורה ומבצע אותם.

כמובן שיש גם קפיצות ולולאות...

אבל בשונה מהתהליך הראשי הוא יכול להתשמש במשתנים הנמצאים בט'רד השכן

מה שנקרא שהוא משתף באותו מרחב זכרון ווירטואלי של התהליך האבא (אותו מיפוי של כתובות לוגיות לפיזיים)

אם יש כמה פעולות מכמה תהליכים מקבילים נוצר תור אצל המעבד

במקרה שיש רק מעבד אחד, או שיש יותר תהליכים מליבות עיבוד

@nigun אמר במה זה ט'רד (thread)?:

(לא יודע איך הוא מנהל את העדיפות בין הט'רדים)

בברירת מחדל (אאל"ט) thread בתוך תהליך מנוהל על ידי ה-scheduler בדיוק כמו תהליך נפרד. ווינדוס מגדירים את ה-thread כה-"Basic scheduling unit". כלומר ניהול התור לא מתייחס בכלל לתהליכים רק ל-thread-ים.

אחרי כל ההתנצלויות שלא פיזיקאי אני ולא בן פזיקאי וכו'

"צפיפות" = היחס של כובד לנפח

כדי שמשהו יצוף על גבי מים הוא חייב צפיפות נמוכה מהמים, אז ברור שהצפיפות של עץ פחות מזה של מים

בד"כ, חומר ספציפי תמיד פחות צפוף במצב נוזלי מאשר במצב מוצק. מים הוא יוצא מן הכלל, כי כידוע קרח צף על פני המים.
אבל אין כלל שאומר שכל נוזל פחות צפוף מכל מוצק

התורמים ל"צפיפות" החומר הם: א) הכובד של האטומים שמרכיבים אותו (ככל שמתקדמים בטבלה המחזורית כך האטומים נהיים יותר כבדים) ב) הצפיפות של המולקולות (= קבוצה של אטומים שמתחברים ביחד) בעצם המדובר.

למרות שאטומי פחמן ושאר המרכיבים של עץ הם יותר כבדים מהאטומים שמרכיבים מים, אבל עץ ביחס למים הוא עצם הרבה הרבה יותר מורכב, יש מבנים נפלאים בכל תא, והתאים מחוברים בצורה מסודרת, לא קשה לדמיין שיש הרבה רווחים בתוך התאים ובינם, מים לעומת הוא פשוט מאוד אוסף של מולוקולות, אין תאים ואין מבנים ולא כלום

עריכה: היה לי טעות, המסה של פחמן 3/4 מהמסה של חמצן, אבל חמצן הוא רק שליש מנפח המים ופחמן הוא חצי הנפח של עץ, אז לכו תעשו חישוב...

אגב, לפעמים עץ יכול לטבוע, לא כל עץ צף

שיחליף איתי כי אני מועף...

@שואף אמר בחידה | לבעלי חוש תיכנות:

חברים בפורום תיכנות שלא פותרים, עפים מהפורום... ( @dovid )

יצויין שזה לא הפרוייקט הראשון בקוד פתוח של ה-NSA, יש עוד המון כאשר הבולט מביניהם הוא Selinux.

למי שמתעניין, יש עוד כמה תוכנות חינמיות שעוזרים בהנדסה לאחור.

• dnspy (דיקומפליזציה כמעט מושלמת של דוטנט)
• JD-Gui (דהקומפליזציה של JAVA - נ"ל שזה לא מעודכן עבור הגירסאות האחרונות של השפה)
• jadx (דהקומפליזציה של אפליקציות אנדראויד)
• Radare2 (דיסאסמבלי וניתוח של קוד מכונה עבור כמה וכמה ארכיטקטורות, כולל יכולות סקריפטינג, כלי די עוצמתי)
• IDA Freeware - (דיסאסמבלי וניתוח עבור קוד מכונה x64 בלבד. יש משהו יותר ישן עבור x86 בלבד)
• ht - (דיסאסמבלי וניתוח של קוד x86 ו-x32)

כלים לזיהוי קבצים

• Die - (מזהה בעיקר תוכנות, יכול לזהות שפות, לפעמים אפילו גירסת קומפיילר, מגינים למיניהם, סוגי אובפסקיזציה, ניתן להרחבה ע"י סקריפטים)
• binwalk - (סקריפט פייתון, טוב בעיקר עבור זיהוי קבצים מוטמעים בקושחות)
• De4dot - זיהוי והשבה לאחור של אובפסקציה

אופסס.. שחכתי לציין הכלי העוצמתי והזמין ביותר - Hex Editor + מסמכי התיעוד של המעבד + המוח האנושי

בשורה ענקית עבור אלה שמתעסקים בהנדסה לאחור של תוכנות. (חוקרי אבטחה, האקרים, סתם סקרנים, ועוד...).

ה-NSA האמריקני (זרוע הסייבר של המדינה) שיחרר לאחרונה כלי שעד עכשיו היה רק בשימוש פנימי בארגון. הכלי הוא פלטפורמה להנדסה לאחור של תוכנות, נכתב בג'אווה, והוא כולל גרעין ופלאגינים לכל מיני ארכיטקטורות, כולל יכולת של דיקומפליזציה של קוד מכונה ל-C עבור כמה ארכיטקטורות, ויכולת סקריפטינג. בקיצור ארגז כלים עוצמתי ביותר.

הכלי שהוא קוד פתוח וחינמי, הוא המתחרה הראשון הרציני ל-IDA PRO, שעד עכשיו היה בלי שום מתחרים רציניים (יש עוד כמה תוכנות שלא מגיעים לקרסוליים שלו). (לשם השוואה, רשיון למחשב אחד עבור תוכנת IDA PRO - כולל פלאגינים לדיקומפליזציה עבור 5 ארכיטקטורות - נמכר נכון לעכשיו במחיר ההזוי של $15,024, וגם לא מוכרים בכלל לסתם אנשים, גם אם תבקש לשלם, רוב הסיכויים שלא יסכימו למכור לך).