נושאים פעיליםנושאים פעילים  הצגת רשימה של חברי הפורוםרשימת משתמשים  חיפוש בפורוםחיפוש  עזרהעזרה
  הרשמההרשמה  התחברותהתחברות RSS עדכונים
אבטחת מידע
RSS UnderWarrior Forums : RSS אבטחת מידע
נושא

נושא: פונ גיבוב - checksums,האשים

 שליחת תגובהשליחת נושא חדש
כותב
הודעה << נושא קודם | נושא הבא >>
אחד שלא יודע
אורח
אורח


הצטרף / הצטרפה: 01 October 2003
משתמש: אונליין
הודעות: 12647
נשלח בתאריך: 21 March 2010 בשעה 20:30 | IP רשוּם
ציטוט אחד שלא יודע

הי

1)

נתקלתי בתופעה חוזרת ונשנה של אלגוריתמים של cheksums (האשים)

וכל מיני אלגוריתמים של הצפנה ,לבצע מוד על מספר ראשוני, לדוגמא באלגוריתם ADLER 32,

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

65535(2^16)

השאלה היא למה דווקא מספר ראשוני?

זה קיים בעוד מקומות (דיפי הלמן לדוגמא)

חיפשתי ברשת,מצאתי דיונים בנושא, אין תשובות חד משמעיות.

חוץ מזה, המתמטיקה שלי לא בשמים אז אני מחפש הסבר בהתאם

2)

אלגוריתם ADLER32 מחשב שני CHECKSUMS באורך 16 ביט ומאחד אותם בסופו של דבר

הראשון הוא סכום הבתים במידע + 1.

קוד:

A = data[0] + data[1] + ...data[n]

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

ז"א

קוד:

B = (1 + data[0]) + (1 + data[0] + data[1]) + (1 + data[0] + data[1] + data[2]) + ...

השאלה היא מה מטרת הסכום הראשון?

השני מאפשר למצוא שגיאות, וגם במקרה שסדר הבתים יוחלף (מה שהראשון לא ימצא)

מה העניין עם הסכום הראשון?

ההסברים דלים כי מי שיוכל להגיב , ידע מראש על מה אני מדבר.

תודה
חזרה לתחילת העמוד הצג את כרטיס החבר של אחד שלא יודע חפש הודעות אחרות של אחד שלא יודע בקר בדף הבית של אחד שלא יודע
 
אחד שעדיין לא יודע
אורח
אורח


הצטרף / הצטרפה: 01 October 2003
משתמש: אונליין
הודעות: 12647
נשלח בתאריך: 21 March 2010 בשעה 22:22 | IP רשוּם
ציטוט אחד שעדיין לא יודע

שכחתי להוסיף קישורים

http://en.wikipedia.org/wiki/Adler-32 - אדלר32

http://en.wikipedia.org/wiki/Diffie%E2%80%93Hellman_key_exchange

דיפי הלמן

 

 

 

 

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

הצטרף / הצטרפה: 09 April 2005
מדינה: Israel
משתמש: מנותק/ת
הודעות: 501
נשלח בתאריך: 23 March 2010 בשעה 11:05 | IP רשוּם
ציטוט cp77fk4r
אתה שואל למה יש שימוש דווקא במספרים ראשוניים?

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


__________________
[Th3rE R mAnY wAyZ 2 r3aD oN3 EmPty p4gE]
חזרה לתחילת העמוד הצג את כרטיס החבר של cp77fk4r חפש הודעות אחרות של cp77fk4r בקר בדף הבית של cp77fk4r
 
inHaze
משתמש פעיל
משתמש פעיל
סמל אישי

הצטרף / הצטרפה: 23 November 2006
מדינה: Israel
משתמש: מנותק/ת
הודעות: 119
נשלח בתאריך: 23 March 2010 בשעה 12:13 | IP רשוּם
ציטוט inHaze
הסיבה שעושים מודולו עם מספר ראשוני היא שלמודולו עם מספר ראשוני יש תכונות ערבול (shuffling) יותר טובות מאשר מספר לא ראשוני (לא בטוח לגבי למה זה קורה אבל אולי זה קשור לעובדה שניתן לייצג כל מספר טבעי כמפלה של מספרים ראשוניים).
לגבי מספרים ראשוניים בכללי הם תופסים חלק מאוד חשוב בתורת המספרים והרבה אלגוריתמים והצפנות (כמו RSA) בנויות עליהם.
החוזק של ההצפנה RSA לדוגמה, מתבסס על הקושי לחשב מספרים ראשוניים מאוד גדולים.


__________________
הבלוג שלי
חזרה לתחילת העמוד הצג את כרטיס החבר של inHaze חפש הודעות אחרות של inHaze
 
אחד שרוצה לדעת
אורח
אורח


הצטרף / הצטרפה: 01 October 2003
משתמש: אונליין
הודעות: 12647
נשלח בתאריך: 23 March 2010 בשעה 12:49 | IP רשוּם
ציטוט אחד שרוצה לדעת

תודה InHaze
CP
סדר הבתים ועוד איך ישפיע על הסכום, כי מיקום הבית משפיע על הסכום הסופי
כי מיקום הבית קובע כמה פעמים הוא יתווסף לסכום.
הבית האחרון יתווסף פעם אחת לסכום הסופי, ואילו הבית הראשון יתווסף N פעמים

תסתכל שוב על B

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

ADLER32

קוד:

public static long adler32(byte [] data)
{
 int A = 1;
 int B = 0;
 
 for(int i=0; i<data.length;i++)
 {
  A = (A + data[i]) % 0xFFF1; //mod 65521
  B = (B + A) % 0xFFF1;
 }

 return (B << 16 | A) & 0xFFFFFFFF;}


תודה inHaze
חזרה לתחילת העמוד הצג את כרטיס החבר של אחד שרוצה לדעת חפש הודעות אחרות של אחד שרוצה לדעת בקר בדף הבית של אחד שרוצה לדעת
 
אחד שרוצה לדעת
אורח
אורח


הצטרף / הצטרפה: 01 October 2003
משתמש: אונליין
הודעות: 12647
נשלח בתאריך: 23 March 2010 בשעה 12:51 | IP רשוּם
ציטוט אחד שרוצה לדעת

data[i]

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

הצטרף / הצטרפה: 16 July 2005
מדינה: Israel
משתמש: מנותק/ת
הודעות: 4637
נשלח בתאריך: 23 March 2010 בשעה 13:55 | IP רשוּם
ציטוט shoshan
אחד שרוצה לדעת כתב:

data[i]

בעיה עם התגים בפורום


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


__________________
עד מתי רשעים יעלוזו?

עַל כֵּן אֶמְאַס וְנִחַמְתִּי עַל עָפָר וָאֵפֶר.
חזרה לתחילת העמוד הצג את כרטיס החבר של shoshan חפש הודעות אחרות של shoshan בקר בדף הבית של shoshan
 
inHaze
משתמש פעיל
משתמש פעיל
סמל אישי

הצטרף / הצטרפה: 23 November 2006
מדינה: Israel
משתמש: מנותק/ת
הודעות: 119
נשלח בתאריך: 23 March 2010 בשעה 14:53 | IP רשוּם
ציטוט inHaze
יכול להיות שמטרת הסכום הראשון היא סתם ליצור ערפול... הרי זה חלק מהמטרה של פונקציית גיבוב.

__________________
הבלוג שלי
חזרה לתחילת העמוד הצג את כרטיס החבר של inHaze חפש הודעות אחרות של inHaze
 
cp77fk4r
מנהל פורומים
מנהל פורומים
סמל אישי
מנהל פורום אבטחת מידע

הצטרף / הצטרפה: 09 April 2005
מדינה: Israel
משתמש: מנותק/ת
הודעות: 501
נשלח בתאריך: 23 March 2010 בשעה 19:24 | IP רשוּם
ציטוט cp77fk4r
"אחד שרוצה לדעת"- צודק, טעות שלי

ובקשר לשאלה שלך על המודולו, אני כמעט בטוח שהלינק הבא יכול לעזור לך:
http://stackoverflow.com/questions/927277/why-modulo-65521-in-adler-32-checksum-algorithm

ואני אצטט מפה:
http://tools.ietf.org/html/rfc3309

קוד:

Adler-32 uses two 16-bit counters, s1 and s2.   s1 is the sum of the
   input, taken as 8-bit bytes.   s2 is a running sum of each value of
   s1.   Both s1 and s2 are computed mod-65521 (the largest prime less
   than 2^16).   Consider a packet of 128 bytes.   The *most* that each
   byte can be is 255.   There are only 128 bytes of input, so the
   greatest value which the s1 accumulator can have is 255 * 128 =
   32640.   So, for 128-byte packets, s1 never wraps.   That is critical.
   Why?

   The key is to consider the distribution of the s1 values, over some
   distribution of the values of the individual input bytes in each
   packet.   Because s1 never wraps, s1 is simply the sum of the
   individual input bytes.   (Even Doug's trick of adding 0x5555 doesn't
   help here, and an even larger value doesn't really help: we can get
   at most one mod-65521 reduction.)



__________________
[Th3rE R mAnY wAyZ 2 r3aD oN3 EmPty p4gE]
חזרה לתחילת העמוד הצג את כרטיס החבר של cp77fk4r חפש הודעות אחרות של cp77fk4r בקר בדף הבית של cp77fk4r
 
אחד שיודע
אורח
אורח


הצטרף / הצטרפה: 01 October 2003
משתמש: אונליין
הודעות: 12647
נשלח בתאריך: 23 March 2010 בשעה 20:45 | IP רשוּם
ציטוט אחד שיודע

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

אם ברצונך להגיב לנושא זה עליך קודם להתחבר
אם אינך רשום/ה כבר עליך להרשם

  שליחת תגובהשליחת נושא חדש
גרסת הדפסה גרסת הדפסה

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