ការអ៊ិនគ្រីប៖ លេខសម្ងាត់ ការរំលាយអាហារ អំបិល និង IV - អ្វីដែលអ្នកត្រូវដឹង

តើការអ៊ិនគ្រីបគឺជាអ្វី?

ការអ៊ិនគ្រីបគឺជាវិធីសាស្រ្តនៃការប្រែក្លាយទិន្នន័យទៅជាទម្រង់ដែលមិនអាចប្រើប្រាស់បាន ដែលអាចមានប្រយោជន៍ដោយមធ្យោបាយនៃការឌិគ្រីបតែប៉ុណ្ណោះ។ គោលបំណងគឺដើម្បីធ្វើឱ្យទិន្នន័យមានសម្រាប់តែអ្នកដែលអាចឌិគ្រីបវាបាន (ពោលគឺធ្វើឱ្យវាអាចប្រើប្រាស់បាន)។ ជាធម្មតា ទិន្នន័យត្រូវតែត្រូវបានអ៊ិនគ្រីប ដើម្បីប្រាកដថាវាមិនអាចទទួលបានក្នុងករណីមានការចូលប្រើដោយគ្មានការអនុញ្ញាត។ វាគឺជាខ្សែការពារចុងក្រោយ បន្ទាប់ពីអ្នកវាយប្រហារបានគ្រប់គ្រងដើម្បីទម្លុះប្រព័ន្ធអនុញ្ញាត និងការគ្រប់គ្រងការចូលប្រើ។

នេះមិនមានន័យថាទិន្នន័យទាំងអស់ត្រូវតែត្រូវបានអ៊ិនគ្រីបទេ ពីព្រោះជាញឹកញាប់ ប្រព័ន្ធអនុញ្ញាត និងការចូលប្រើអាចគ្រប់គ្រាន់ ហើយលើសពីនេះទៀត មានការផាកពិន័យលើការអនុវត្តសម្រាប់ការអ៊ិនគ្រីប និងឌិគ្រីបទិន្នន័យ។ ប្រសិនបើ និងនៅពេលដែលទិន្នន័យត្រូវបានអ៊ិនគ្រីប គឺជាបញ្ហានៃការរៀបចំផែនការកម្មវិធី និងការវាយតម្លៃហានិភ័យ ហើយពេលខ្លះ វាក៏ជាតម្រូវការបទប្បញ្ញត្តិផងដែរ ដូចជាជាមួយ HIPAA ឬ GDPR ជាដើម។

ទិន្នន័យអាចត្រូវបានអ៊ិនគ្រីបនៅពេលសម្រាក ដូចជានៅលើថាស ឬក្នុងការដឹកជញ្ជូន ដូចជារវាងភាគីទាំងពីរដែលទាក់ទងគ្នាតាមអ៊ីនធឺណិត។

នៅទីនេះ អ្នកនឹងរៀនពីរបៀបអ៊ិនគ្រីប និងឌិគ្រីបទិន្នន័យដោយប្រើពាក្យសម្ងាត់ ដែលត្រូវបានគេស្គាល់ថាជាការអ៊ិនគ្រីបស៊ីមេទ្រី។ ពាក្យ​សម្ងាត់​នេះ​ត្រូវ​តែ​ដឹង​ដល់​ភាគី​ទាំង​ពីរ​ដែល​ផ្លាស់​ប្តូរ​ព័ត៌មាន។

Cipher, Digest, Salt, Iterations, IV

ដើម្បីប្រើការអ៊ិនគ្រីបឱ្យបានត្រឹមត្រូវ និងមានសុវត្ថិភាព មានសញ្ញាណមួយចំនួនដែលចាំបាច់ត្រូវពន្យល់។

លេខសម្ងាត់គឺជាក្បួនដោះស្រាយដែលប្រើសម្រាប់ការអ៊ិនគ្រីប។ ឧទាហរណ៍ AES256 គឺជាលេខសម្ងាត់។ គំនិតនៃលេខកូដសម្ងាត់គឺជាអ្វីដែលមនុស្សភាគច្រើននឹងគិតនៅពេលនិយាយអំពីការអ៊ិនគ្រីប។

ការវិភាគជាមូលដ្ឋានគឺជាមុខងារ hash ដែលត្រូវបានប្រើដើម្បីច្របូកច្របល់ និងពង្រីកពាក្យសម្ងាត់ (ឧ. លេខកូដសម្ងាត់) មុនពេលវាត្រូវបានប្រើដោយលេខកូដសម្ងាត់។ តើ​ហេតុ​អ្វី​បាន​ជា​ធ្វើ​បែប​នេះ? សម្រាប់មួយ វាបង្កើតការចៃដន្យ និងប្រវែងឯកសណ្ឋាននៃគន្លឹះដែលដំណើរការប្រសើរជាងមុនសម្រាប់ការអ៊ិនគ្រីប។ វាក៏សមរម្យសម្រាប់ "អំបិល" ដែលជាការនិយាយបន្ទាប់។

"អំបិល" គឺជាវិធីសាស្រ្តនៃការកម្ចាត់តុ "ឥន្ទធនូ" ។ អ្នកវាយប្រហារដឹងថាតម្លៃ hash ពីរនឹងនៅតែដូចគ្នាបេះបិទ ប្រសិនបើតម្លៃដើម។ ទោះយ៉ាងណាក៏ដោយ ប្រសិនបើអ្នកបន្ថែមតម្លៃអំបិលទៅ hashing នោះពួកគេនឹងមិនធ្វើទេ។ វាត្រូវបានគេហៅថា "អំបិល" ព្រោះវាជាប្រភេទនៃការលាយបញ្ចូលគ្នាជាមួយនឹងគន្លឹះក្នុងការផលិតអ្វីប្លែក។

ឥឡូវនេះ តារាងឥន្ទធនូនឹងព្យាយាមផ្គូផ្គងតម្លៃ hashed ដែលស្គាល់ជាមួយនឹងទិន្នន័យដែលបានគណនាជាមុនក្នុងកិច្ចខិតខំប្រឹងប្រែងដើម្បីទាយពាក្យសម្ងាត់។

ជាធម្មតា អំបិលត្រូវបានបង្កើតដោយចៃដន្យសម្រាប់សោនីមួយៗ ហើយរក្សាទុកជាមួយវា។ ដើម្បីផ្គូផ្គង hashes ដែលគេស្គាល់ អ្នកវាយប្រហារនឹងត្រូវរៀបចំតារាងឥន្ទធនូជាមុនសម្រាប់តម្លៃចៃដន្យជាច្រើន ដែលជាទូទៅមិនអាចទៅរួចនោះទេ។

អ្នកនឹងឮជាញឹកញាប់អំពី "ការសរសេរឡើងវិញ" នៅក្នុងការអ៊ិនគ្រីប។ ការ​ធ្វើ​ឡើងវិញ​គឺជា​វដ្ដ​តែមួយ​ដែល​គ្រាប់ចុច​និង​អំបិល​ត្រូវ​បាន​លាយ​បញ្ចូល​គ្នា​ក្នុង​របៀប​មួយ​ដើម្បី​ធ្វើ​ឱ្យ​ការ​ស្មាន​គន្លឹះ​កាន់តែ​ពិបាក។ នេះត្រូវបានធ្វើច្រើនដង ដើម្បីឱ្យវាពិបាកគណនាសម្រាប់អ្នកវាយប្រហារក្នុងការបញ្ច្រាស-ទាយគន្លឹះ ដូច្នេះ "ការនិយាយឡើងវិញ" (ពហុវចនៈ)។ ជាធម្មតា ចំនួនអប្បរមានៃការធ្វើម្តងទៀតគឺ 1000 ប៉ុន្តែវាអាចខុសគ្នាជាងនោះ។ ប្រសិនបើអ្នកចាប់ផ្តើមជាមួយពាក្យសម្ងាត់ខ្លាំង ជាទូទៅអ្នកត្រូវការតិចជាងនេះ។

IV (ឬ "Initialization Vector") ជាធម្មតាជាតម្លៃចៃដន្យដែលត្រូវបានប្រើសម្រាប់ការអ៊ិនគ្រីបនៃសារនីមួយៗ។ ឥឡូវនេះ អំបិល​ត្រូវ​បាន​ប្រើ​សម្រាប់​ផលិត​សោ​ដោយ​ផ្អែក​លើ​ពាក្យ​សម្ងាត់។ ហើយ IV ត្រូវបានប្រើនៅពេលដែលអ្នកមានសោរួចហើយ ហើយឥឡូវនេះកំពុងអ៊ិនគ្រីបសារ។ គោលបំណងនៃ IV គឺដើម្បីធ្វើឱ្យសារដូចគ្នាលេចឡើងខុសគ្នានៅពេលអ៊ិនគ្រីប។ ពេលខ្លះ IV ក៏មានសមាសភាគបន្តបន្ទាប់គ្នា ដូច្នេះវាត្រូវបានផលិតចេញពីខ្សែចៃដន្យបូកនឹងលំដាប់ដែលកើនឡើងឥតឈប់ឈរ។

វាធ្វើឱ្យការវាយប្រហារ "លេងឡើងវិញ" ពិបាក ដែលជាកន្លែងដែលអ្នកវាយប្រហារមិនចាំបាច់ឌិគ្រីបសារ។ ផ្ទុយទៅវិញ សារដែលបានអ៊ិនគ្រីបត្រូវបាន "ហិតក្លិន" (មានន័យថា ស្ទាក់ចាប់រវាងអ្នកផ្ញើ និងអ្នកទទួល) ហើយបន្ទាប់មកចាក់សារជាថ្មី ដោយសង្ឃឹមថានឹងធ្វើម្តងទៀតនូវសកម្មភាពដែលបានអនុវត្តរួចហើយ។ ទោះបីជាការពិត ពិធីការកម្រិតខ្ពស់ភាគច្រើនមានលំដាប់លំដោយរួចហើយ ដែលសារនីមួយៗមានជាផ្នែកមួយរបស់វា ការកើនឡើងចំនួនកញ្ចប់ព័ត៌មាន ដូច្នេះក្នុងករណីភាគច្រើន IV មិនត្រូវការវាទេ។

តម្រូវការជាមុន

ឧទាហរណ៍នេះប្រើក្របខ័ណ្ឌ Gliimly ។ ដំឡើង វាជាមុនសិន។

ឧទាហរណ៍នៃការអ៊ិនគ្រីប

ដើម្បីដំណើរការឧទាហរណ៍នៅទីនេះ បង្កើតកម្មវិធី "enc" នៅក្នុងថតរបស់វាផ្ទាល់ (សូមមើល mgrg សម្រាប់បន្ថែមលើកម្មវិធីគ្រប់គ្រងកម្មវិធីរបស់ Gliimly):

 mkdir enc_example cd enc_example gg -k enc

ដើម្បីអ៊ិនគ្រីបទិន្នន័យ ប្រើសេចក្តីថ្លែងការណ៍ អ៊ិនគ្រីបទិន្នន័យ ។ ទម្រង់​សាមញ្ញ​បំផុត​គឺ​ការ​អ៊ិនគ្រីប​ខ្សែអក្សរ​ដែល​បាន​បញ្ចប់​ជា​មោឃៈ។ បង្កើតឯកសារ "encrypt.gliim" ហើយចម្លងវា៖

 begin-handler /encrypt public set-string str = "This contains a secret code, which is Open Sesame!" // Encrypt encrypt-data str to enc_str password "my_password" p-out enc_str @ // Decrypt decrypt-data enc_str password "my_password" to dec_str p-out dec_str @ end-handler

អ្នកអាចឃើញការប្រើប្រាស់ជាមូលដ្ឋាននៃទិន្នន័យអ៊ិនគ្រីប និង ឌិគ្រីបទិន្នន័យ ។ អ្នកផ្គត់ផ្គង់ទិន្នន័យ (ដើម ឬអ៊ិនគ្រីប) និងពាក្យសម្ងាត់ ហើយបិទអ្នកទៅ។ ទិន្នន័យ​ត្រូវ​បាន​អ៊ិនគ្រីប ហើយ​បន្ទាប់​មក​ត្រូវ​បាន​ឌិគ្រីប ដោយ​ផ្តល់​ផល​ដើម។

នៅក្នុងកូដប្រភព អថេរខ្សែអក្សរ "enc_str" (ដែលត្រូវបានបង្កើតជា "char*") នឹងមានកំណែដែលបានអ៊ិនគ្រីបនៃ "This contains a secret code, which is Open Sesame!" ហើយ "dec_str" នឹងជាទិន្នន័យដែលបានឌិគ្រីប ដែលត្រូវតែដូចគ្នាបេះបិទ។

ដើម្បីដំណើរការកូដនេះពីបន្ទាត់ពាក្យបញ្ជា សូមបង្កើតកម្មវិធីជាមុនសិន៖

 gg -q

បន្ទាប់មក Gliimly ផលិតកូដ bash ដើម្បីដំណើរការវា - ផ្លូវស្នើសុំគឺ "/encrypt" ដែលក្នុងករណីរបស់យើងត្រូវបានគ្រប់គ្រងដោយមុខងារ "void encrypt()" ដែលកំណត់ក្នុងប្រភពឯកសារ "encrypt.gliim"។ នៅក្នុង Gliimly ឈ្មោះទាំងនេះតែងតែត្រូវគ្នា ដែលធ្វើឱ្យវាងាយស្រួលក្នុងការសរសេរ អាន និងប្រតិបត្តិកូដ។ ប្រើជម្រើស "-r" នៅក្នុង gg ដើម្បីបញ្ជាក់ផ្លូវស្នើសុំ និងទទួលបានលេខកូដដែលអ្នកត្រូវការដើម្បីដំណើរការកម្មវិធី៖

 gg -r --req="/encrypt" --silent-header --exec

អ្នកនឹងទទួលបានការឆ្លើយតបដូចនេះ៖

 72ddd44c10e9693be6ac77caabc64e05f809290a109df7cfc57400948cb888cd23c7e98e15bcf21b25ab1337ddc6d02094232111aa20a2d548c08f230b6d56e9 This contains a secret code, which is Open Sesame!

អ្វីដែលអ្នកមាននៅទីនេះគឺទិន្នន័យដែលបានអ៊ិនគ្រីប ហើយបន្ទាប់មកទិន្នន័យដែលបានអ៊ិនគ្រីបនេះត្រូវបានឌិគ្រីបដោយប្រើពាក្យសម្ងាត់ដូចគ្នា។ មិនគួរឱ្យភ្ញាក់ផ្អើលទេ លទ្ធផលត្រូវគ្នានឹងខ្សែអក្សរដែលអ្នកបានអ៊ិនគ្រីបពីដំបូង។

ចំណាំថាតាមលំនាំដើម ទិន្នន័យអ៊ិនគ្រីបនឹងបង្កើតតម្លៃដែលបានអ៊ិនគ្រីបក្នុងទម្រង់លេខគោលដប់ប្រាំមួយដែលអាចអានបានរបស់មនុស្ស ដែលមានន័យថាមានតួអក្សរគោលដប់ប្រាំមួយ "0" ទៅ "9" និង "a" ទៅ "f" ។ វិធីនេះ អ្នកអាចរក្សាទុកទិន្នន័យដែលបានអ៊ិនគ្រីបចូលទៅក្នុងខ្សែអក្សរធម្មតា។ ឧទាហរណ៍ វាអាចទៅឯកសារ JSON ចូលទៅក្នុងជួរឈរ VARCHAR នៅក្នុងមូលដ្ឋានទិន្នន័យ ឬស្ទើរតែគ្រប់ទីកន្លែង។ ទោះយ៉ាងណាក៏ដោយ អ្នកក៏អាចបង្កើតទិន្នន័យដែលបានអ៊ិនគ្រីបប្រព័ន្ធគោលពីរផងដែរ។ បន្ថែមទៀតអំពីវាបន្តិច។

អ៊ិនគ្រីបទិន្នន័យទៅក្នុងលទ្ធផលគោលពីរ

នៅក្នុងឧទាហរណ៍មុន ទិន្នន័យដែលបានអ៊ិនគ្រីបជាលទ្ធផលគឺនៅក្នុងទម្រង់លេខគោលដប់ប្រាំមួយដែលអាចអានបានដោយមនុស្ស។ អ្នកក៏អាចបង្កើតទិន្នន័យដែលបានអ៊ិនគ្រីបប្រព័ន្ធគោលពីរ ដែលមិនមែនជាខ្សែអក្សរដែលអាចអានបានដោយមនុស្ស និងខ្លីជាងនេះផងដែរ។ ដើម្បីធ្វើដូច្នេះសូមប្រើឃ្លា "គោលពីរ" ។ ជំនួសលេខកូដនៅក្នុង "encrypt.gliim" ជាមួយ៖

 begin-handler /encrypt public set-string str = "This contains a secret code, which is Open Sesame!" // Encrypt encrypt-data str to enc_str password "my_password" binary // Save the encrypted data to a file write-file "encrypted_data" from enc_str get-app directory to app_dir @Encrypted data written to file <<p-out app_dir>>/encrypted_data // Decrypt data decrypt-data enc_str password "my_password" binary to dec_str p-out dec_str @ end-handler

នៅពេលដែលអ្នកចង់ទទួលបានទិន្នន័យដែលបានអ៊ិនគ្រីបប្រព័ន្ធគោលពីរ អ្នកគួរតែទទួលបានប្រវែងរបស់វាជាបៃផងដែរ ឬបើមិនដូច្នេះទេ អ្នកនឹងមិនដឹងថាវាបញ្ចប់នៅទីណាទេ ព្រោះវាអាចមាន null bytes នៅក្នុងវា។ ប្រើឃ្លា "ប្រវែងលទ្ធផល" សម្រាប់គោលបំណងនោះ។ នៅក្នុងកូដនេះ ទិន្នន័យដែលបានអ៊ិនគ្រីបនៅក្នុងអថេរ "enc_str" ត្រូវបានសរសេរទៅឯកសារ "encrypted_data" ហើយប្រវែងដែលសរសេរគឺ "outlen" បៃ។

នៅពេលដែលឯកសារត្រូវបានសរសេរដោយគ្មានផ្លូវ វាតែងតែត្រូវបានសរសេរនៅក្នុងថតផ្ទះកម្មវិធី (សូមមើល ថត ) ដូច្នេះអ្នកនឹងប្រើ កម្មវិធី get-app ដើម្បីទទួលបានថតនោះ។

នៅពេលឌិគ្រីបទិន្នន័យ សូមកត់សម្គាល់ការប្រើប្រាស់ឃ្លា "ប្រវែងបញ្ចូល" ។ វានិយាយថាចំនួនបៃដែលទិន្នន័យដែលបានអ៊ិនគ្រីបមាន។ ជាក់ស្តែង អ្នកអាចទទួលបានវាពីអថេរ "outlen" ដែលការអ៊ិនគ្រីបទិន្នន័យរក្សាទុករយៈពេលនៃទិន្នន័យដែលបានអ៊ិនគ្រីប។ នៅពេលដែលការអ៊ិនគ្រីប និងការឌិគ្រីបត្រូវបានបំបែក ពោលគឺដំណើរការក្នុងកម្មវិធីដាច់ដោយឡែក អ្នកត្រូវប្រាកដថាប្រវែងនេះត្រូវបានធ្វើឱ្យមាន។

សូមកត់សម្គាល់ផងដែរថានៅពេលដែលទិន្នន័យត្រូវបានអ៊ិនគ្រីបជា "ប្រព័ន្ធគោលពីរ" (មានន័យថាបង្កើតលទ្ធផលប្រព័ន្ធគោលពីរ) ការឌិគ្រីបត្រូវតែប្រើដូចគ្នា។

បង្កើតកម្មវិធី៖

 gg -q

ដំណើរការវាដូចពីមុន៖

 gg -r --req="/encrypt" --silent-header --exec

លទ្ធផលគឺ៖

 Encrypted data written to file /var/lib/gg/enc/app/encrypted_data This contains a secret code, which is Open Sesame!

ទិន្នន័យដែលបានឌិគ្រីបគឺដូចគ្នាបេះបិទទៅនឹងទិន្នន័យដើម។

អ្នក​អាច​មើល​ឃើញ​ទិន្នន័យ​ដែល​បាន​អ៊ិនគ្រីប​ពិតប្រាកដ​ដែល​បាន​សរសេរ​ទៅ​ឯកសារ​ដោយ​ប្រើ "octal dump" ("od") ឧបករណ៍​ប្រើប្រាស់​លីនុច៖

 od -c /var/lib/gg/enc/app/encrypted_data

ជាមួយនឹងលទ្ធផលដូចជា៖

 $ od -c /var/lib/gg/enc/app/encrypted_data 0000000 r 335 324 L 020 351 i ; 346 254 w 312 253 306 N 005 0000020 370 \t ) \n 020 235 367 317 305 t \0 224 214 270 210 315 0000040 # 307 351 216 025 274 362 033 % 253 023 7 335 306 320 0000060 224 # ! 021 252 242 325 H 300 217 # \vm V 351 0000100

នៅទីនោះអ្នកមានវា។ អ្នក​នឹង​សម្គាល់​ឃើញ​ថា​ទិន្នន័យ​គឺ​ជា​ប្រព័ន្ធ​គោលពីរ ហើយ​វា​ពិត​ជា​មាន​បៃ​បៃ​ទទេ។

អ៊ិនគ្រីបទិន្នន័យគោលពីរ

ទិន្នន័យដែលត្រូវអ៊ិនគ្រីបក្នុងឧទាហរណ៍ទាំងនេះគឺជាខ្សែអក្សរ ពោលគឺគ្មានកំណត់ព្រំដែន។ អ្នកអាចអ៊ិនគ្រីបទិន្នន័យគោលពីរយ៉ាងងាយស្រួលដោយបញ្ជាក់វាទាំងមូល (ចាប់តាំងពី Gliimly តាមដានថាតើមានប៉ុន្មានបៃ!) ឬបញ្ជាក់ប្រវែងរបស់វានៅក្នុងឃ្លា "input-length" ឧទាហរណ៍ ចម្លងវាទៅ "encrypt.gliim"៖

 begin-handler /encrypt public set-string str = "This c\000ontains a secret code, which is Open Sesame!" // Encrypt encrypt-data str to enc_str password "my_password" input-length 12 p-out enc_str @ // Decrypt decrypt-data enc_str password "my_password" to dec_str // Output binary data; present null byte as octal \000 string-length dec_str to res_len start-loop repeat res_len use i start-with 0 if-true dec_str[i] equal 0 p-out "\\000" else-if pf-out "%c", dec_str[i] end-if end-loop @ end-handler

វានឹងអ៊ិនគ្រីប 12 បៃនៅទីតាំងអង្គចងចាំ "enc_str" ដោយមិនគិតពីបៃបៃណាមួយឡើយ។ ក្នុង​ករណី​នេះ នោះ​ជា "គ" ដែល​តាម​ពី​ក្រោយ​ដោយ null byte អម​ដោយ​ខ្សែអក្សរ "ontain" ប៉ុន្តែ​វា​អាច​ជា​ប្រភេទ​នៃ​ទិន្នន័យ​គោលពីរ​ណាមួយ ឧទាហរណ៍ មាតិកា​នៃ​ឯកសារ JPG ។

នៅផ្នែកឌិគ្រីប អ្នកនឹងទទួលបានចំនួនបៃដែលបានឌិគ្រីបក្នុងឃ្លា "ប្រវែងលទ្ធផល"។ ជាចុងក្រោយ ទិន្នន័យដែលបានឌិគ្រីបត្រូវបានបង្ហាញថាពិតជាដើម ហើយបៃបៃទទេត្រូវបានបង្ហាញជាតំណាងគោលប្រាំបីធម្មតា។

បង្កើតកម្មវិធី៖

 gg -q

ដំណើរការវាដូចពីមុន៖

 gg -r --req="/encrypt" --silent-header --exec

លទ្ធផលគឺ៖

 6bea45c2f901c0913c87fccb9b347d0a This c\000ontai

តម្លៃដែលបានអ៊ិនគ្រីបគឺខ្លីជាង ពីព្រោះទិន្នន័យក៏ខ្លីជាងក្នុងករណីនេះដែរ ហើយលទ្ធផលត្រូវគ្នានឹងដើមពិតប្រាកដ។

ប្រើ Cipher ឬ Digest ណាមួយ។

ការអ៊ិនគ្រីបដែលប្រើតាមលំនាំដើមគឺ AES256 និង SHA256 hashing ពីបណ្ណាល័យ OpenSSL ស្តង់ដារ ដែលទាំងពីរនេះត្រូវបានប្រើប្រាស់យ៉ាងទូលំទូលាយក្នុងការគ្រីប។ ទោះយ៉ាងណាក៏ដោយ អ្នកអាចប្រើ cipher និង digest ដែលអាចប្រើបាន (ឧទាហរណ៍ hash) ដែលត្រូវបានគាំទ្រដោយ OpenSSL (សូម្បីតែអ្នកផ្តល់អោយ)។

ដើម្បី​មើល​ថា​ក្បួន​ដោះស្រាយ​ណា​ដែល​មាន សូម​ធ្វើ​វា​ក្នុង​បន្ទាត់​ពាក្យ​បញ្ជា៖

 #get list of cipher providers openssl list -cipher-algorithms #get list of digest providers openssl list -digest-algorithms

ទាំង​ពីរ​នេះ​នឹង​ផ្តល់​នូវ​បញ្ជី​នៃ​លេខ​កូដ​សម្ងាត់​និង​ការ​រំលាយ (hash) algorithms ។ ពួកវាខ្លះអាចខ្សោយជាងលំនាំដើមដែលត្រូវបានជ្រើសរើសដោយ Gliimly ហើយអ្នកផ្សេងទៀតអាចនៅទីនោះសម្រាប់តែភាពឆបគ្នាថយក្រោយជាមួយប្រព័ន្ធចាស់ៗប៉ុណ្ណោះ។ ទោះជាយ៉ាងណាក៏ដោយ អ្នកផ្សេងទៀតប្រហែលជាថ្មីស្រឡាង ហើយមិនមានពេលវេលាគ្រប់គ្រាន់ដើម្បីបញ្ជាក់ឱ្យច្បាស់តាមកម្រិតដែលអ្នកចង់ឱ្យពួកគេក្លាយជានោះទេ។

ដូច្នេះ សូមប្រយ័ត្នពេលជ្រើសរើសក្បួនដោះស្រាយទាំងនេះ ហើយត្រូវប្រាកដថាដឹងពីមូលហេតុដែលអ្នកកំពុងផ្លាស់ប្តូរលំនាំដើម។ ដែលបាននិយាយថា នេះគឺជាឧទាហរណ៍នៃការប្រើប្រាស់ Camellia-256 (ពោលគឺ "CAMELLIA-256-CFB1") ការអ៊ិនគ្រីបជាមួយ "SHA3-512" digest ។ ជំនួសលេខកូដនៅក្នុង "encrypt.gliim" ជាមួយ៖

 begin-handler /encrypt public set-string str = "This contains a secret code, which is Open Sesame!" // Encrypt data encrypt-data str to enc_str password "my_password" \ cipher "CAMELLIA-256-CFB1" digest "SHA3-512" p-out enc_str @ // Decrypt data decrypt-data enc_str password "my_password" to dec_str \ cipher "CAMELLIA-256-CFB1" digest "SHA3-512" p-out dec_str @ end-handler

បង្កើតកម្មវិធី៖

 gg -q

ដំណើរការវា៖

 gg -r --req="/encrypt" --silent-header --exec

ក្នុងករណីនេះលទ្ធផលគឺ៖

 f4d64d920756f7220516567727cef2c47443973de03449915d50a1d2e5e8558e7e06914532a0b0bf13842f67f0a268c98da6 This contains a secret code, which is Open Sesame!

ជាថ្មីម្តងទៀត អ្នកទទួលបានទិន្នន័យដើម។ ចំណាំ អ្នកត្រូវតែប្រើ cipher និង digest ដូចគ្នាទាំងក្នុង encrypt-data និង decrypt-data!

ជា​ការ​ពិត​ណាស់ អ្នក​អាច​ផលិត​តម្លៃ​ដែល​បាន​អ៊ិនគ្រីប​ប្រព័ន្ធ​គោលពីរ​ដូច​មុន​ដោយ​ប្រើ​ឃ្លា "គោលពីរ" និង "ប្រវែង​លទ្ធផល"។

ប្រសិនបើអ្នកមានប្រព័ន្ធខាងក្រៅដែលអ៊ិនគ្រីបទិន្នន័យ ហើយអ្នកដឹងថាលេខកូដសម្ងាត់មួយណាដែលពួកវាប្រើនោះ អ្នកអាចផ្គូផ្គងកូដទាំងនោះ និងធ្វើឱ្យកូដរបស់អ្នកអាចធ្វើអន្តរកម្មបាន។ Gliimly ប្រើបណ្ណាល័យ OpenSSL ស្តង់ដារ ដូច្នេះឱកាសដែលកម្មវិធីផ្សេងទៀតក៏អាចផងដែរ។

ការប្រើប្រាស់អំបិល

ដើម្បីបន្ថែមអំបិលទៅការអ៊ិនគ្រីប សូមប្រើឃ្លា "អំបិល" ។ អ្នកអាចបង្កើតអំបិលចៃដន្យដោយប្រើសេចក្តីថ្លែងការណ៍ random-string (ឬ random-crypto ប្រសិនបើមានតម្រូវការ)។ នេះគឺជាកូដសម្រាប់ "encrypt.gliim"៖

 begin-handler /encrypt public set-string str = "This contains a secret code, which is Open Sesame!" // Get salt random-string to rs length 16 // Encrypt data encrypt-data str to enc_str password "my_password" salt rs @Salt used is <<p-out rs>>, and the encrypted string is <<p-out enc_str>> // Decrypt data decrypt-data enc_str password "my_password" salt rs to dec_str p-out dec_str @ end-handler

បង្កើតកម្មវិធី៖

 gg -q

ដំណើរការវាពីរបីដង៖

 gg -r --req="/encrypt" --silent-header --exec gg -r --req="/encrypt" --silent-header --exec gg -r --req="/encrypt" --silent-header --exec

លទ្ធផល៖

 Salt used is VA9agPKxL9hf3bMd, and the encrypted string is 3272aa49c9b10cb2edf5d8a5e23803a5aa153c1b124296d318e3b3ad22bc911d1c0889d195d800c2bd92153ef7688e8d1cd368dbca3c5250d456f05c81ce0fdd This contains a secret code, which is Open Sesame! Salt used is FeWcGkBO5hQ1uo1A, and the encrypted string is 48b97314c1bc88952c798dfde7a416180dda6b00361217ea25278791c43b34f9c2e31cab6d9f4f28eea59baa70aadb4e8f1ed0709db81dff19f24cb7677c7371 This contains a secret code, which is Open Sesame! Salt used is nCQClR0NMjdetTEf, and the encrypted string is f19cdd9c1ddec487157ac727b2c8d0cdeb728a4ecaf838ca8585e279447bcdce83f7f95fa53b054775be1bb2de3b95f2e66a8b26b216ea18aa8b47f3d177e917 This contains a secret code, which is Open Sesame!

ដូចដែលអ្នកអាចឃើញ តម្លៃអំបិលចៃដន្យ (16 បៃក្នុងករណីនេះ) ត្រូវបានបង្កើតសម្រាប់ការអ៊ិនគ្រីបនីមួយៗ ហើយតម្លៃដែលបានអ៊ិនគ្រីបគឺខុសគ្នារាល់ពេល ទោះបីជាទិន្នន័យដែលត្រូវបានអ៊ិនគ្រីបដូចគ្នាក៏ដោយ! វាធ្វើឱ្យមានការលំបាកក្នុងការបំបែកការអ៊ិនគ្រីបដូចនេះ។

ជា​ការ​ពិត​ណាស់ ដើម្បី​ឌិគ្រីប អ្នក​ត្រូវ​កត់ត្រា​អំបិល ហើយ​ប្រើ​វា​ឱ្យ​បាន​ច្បាស់​ដូច​ដែល​អ្នក​បាន​ធ្វើ​នៅ​ពេល​អ៊ិនគ្រីប។ នៅក្នុងកូដនៅទីនេះ អថេរ "rs" ផ្ទុកអំបិល។ ប្រសិនបើអ្នករក្សាទុកតម្លៃដែលបានអ៊ិនគ្រីបនៅក្នុងមូលដ្ឋានទិន្នន័យ អ្នកទំនងជារក្សាទុកអំបិលនៅជាប់វា។

វ៉ិចទ័រការចាប់ផ្តើម

នៅក្នុងការអនុវត្ត អ្នកនឹងមិនប្រើតម្លៃអំបិលខុសគ្នាសម្រាប់សារនីមួយៗទេ។ វាបង្កើតសោថ្មីរាល់ពេល ហើយវាអាចកាត់បន្ថយដំណើរការបាន។ ហើយវាពិតជាមិនចាំបាច់សម្រាប់វាទេ៖ ការប្រើប្រាស់អំបិលគឺដើម្បីធ្វើឱ្យកូនសោនីមួយៗ (សូម្បីតែដូចគ្នា) កាន់តែពិបាកស្មាន។ នៅពេលដែលអ្នកបានធ្វើរួច អ្នកប្រហែលជាមិនចាំបាច់ធ្វើវាម្តងទៀត ឬញឹកញាប់ទេ។

ជំនួសមកវិញ អ្នកនឹងប្រើ IV (Initialization Vector) សម្រាប់សារនីមួយៗ។ ជាធម្មតា វា​ជា​ខ្សែអក្សរចៃដន្យ​ដែល​ធ្វើ​ឱ្យ​សារ​ដូចគ្នា​លេចឡើង​ខុស​គ្នា និង​បង្កើន​តម្លៃ​គណនា​នៃ​ការ​បំបែក​ពាក្យសម្ងាត់។ នេះគឺជាកូដថ្មីសម្រាប់ "encrypt.gliim"៖

 begin-handler /encrypt public // Get salt random-string to rs length 16 // Encrypt data start-loop repeat 10 use i start-with 0 random-string to iv length 16 encrypt-data "The same message" to enc_str password "my_password" salt rs iterations 2000 init-vector iv cache @The encrypted string is <<p-out enc_str>> // Decrypt data decrypt-data enc_str password "my_password" salt rs iterations 2000 init-vector iv to dec_str cache p-out dec_str @ end-loop end-handler

បង្កើតកម្មវិធី៖

 gg -q

ដំណើរការវាពីរបីដង៖

 gg -r --req="/encrypt" --silent-header --exec gg -r --req="/encrypt" --silent-header --exec gg -r --req="/encrypt" --silent-header --exec

លទ្ធផលអាចជា៖

 The encrypted string is 787909d332fd84ba939c594e24c421b00ba46d9c9a776c47d3d0a9ca6fccb1a2 The same message The encrypted string is 7fae887e3ae469b666cff79a68270ea3d11b771dc58a299971d5b49a1f7db1be The same message The encrypted string is 59f95c3e4457d89f611c4f8bd53dd5fa9f8c3bbe748ed7d5aeb939ad633199d7 The same message The encrypted string is 00f218d0bbe7b618a0c2970da0b09e043a47798004502b76bc4a3f6afc626056 The same message The encrypted string is 6819349496b9f573743f5ef65e27ac26f0d64574d39227cc4e85e517f108a5dd The same message The encrypted string is a2833338cf636602881377a024c974906caa16d1f7c47c78d9efdff128918d58 The same message The encrypted string is 04c914cd9338fcba9acb550a79188bebbbb134c34441dfd540473dd8a1e6be40 The same message The encrypted string is 05f0d51561d59edf05befd9fad243e0737e4a98af357a9764cba84bcc55cf4d5 The same message The encrypted string is ae594c4d6e72c05c186383e63c89d93880c8a8a085bf9367bdfd772e3c163458 The same message The encrypted string is 2b28cdf5a67a5a036139fd410112735aa96bc341a170dafb56818dc78efe2e00 The same message

អ្នក​អាច​ឃើញ​ថា​សារ​ដូចគ្នា​បង្ហាញ​ភាព​ខុស​គ្នា​នៅ​ពេល​ដែល​បាន​អ៊ិនគ្រីប​ ទោះ​បី​ជា​ពេល​ឌិគ្រីប​ក៏​វា​ដូច​គ្នា​ម្ដង​ទៀត។ ជាការពិតណាស់ ពាក្យសម្ងាត់ អំបិល ចំនួននៃការធ្វើឡើងវិញ និង init-vector ត្រូវតែដូចគ្នាសម្រាប់ទាំងការអ៊ិនគ្រីប និងការឌិគ្រីប។

ចំណាំការប្រើប្រាស់ឃ្លា "ឃ្លាំងសម្ងាត់" នៅក្នុងការអ៊ិនគ្រីបទិន្នន័យ និងឌិគ្រីបទិន្នន័យ។ វា​រក្សា​ទុក​សោ​ដែល​បាន​គណនា​យ៉ាង​មាន​ប្រសិទ្ធភាព (លេខ​សម្ងាត់​ដែល​បាន​ផ្តល់​ឱ្យ អំបិល ក្បួន​ដោះស្រាយ​លេខ​សម្ងាត់/រំលាយ និង​ចំនួន​នៃ​ការ​ធ្វើ​ឡើងវិញ) ដូច្នេះ​វា​មិន​ត្រូវ​បាន​គណនា​រាល់​ពេល​តាម​រង្វិល​ជុំ​ទេ។ ជាមួយនឹង "ឃ្លាំងសម្ងាត់" គន្លឹះត្រូវបានគណនាម្តង ហើយបន្ទាប់មក IV ផ្សេងគ្នា (នៅក្នុងឃ្លា "init-vector") ត្រូវបានប្រើសម្រាប់សារនីមួយៗ។

ប្រសិនបើអ្នកចង់បង្កើតសោឡើងវិញម្តងម្កាល សូមប្រើឃ្លា "clear-cache" ដែលផ្គត់ផ្គង់ប៊ូលីន។ ប្រសិនបើពិត សោត្រូវបានគណនាឡើងវិញ បើមិនដូច្នេះទេ វាទុកចោលតែម្នាក់ឯង។ សូមមើល encrypt-data សម្រាប់ព័ត៌មានបន្ថែមអំពីរឿងនេះ។

សេចក្តីសន្និដ្ឋាន

អ្នកបានរៀនពីរបៀបអ៊ិនគ្រីប និងឌិគ្រីបទិន្នន័យដោយប្រើលេខសម្ងាត់ ការរំលាយអាហារ អំបិល និងតម្លៃ IV ផ្សេងៗគ្នានៅក្នុង Gliimly។ អ្នកក៏អាចបង្កើតតម្លៃអ៊ីនគ្រីបដែលអាចអានបានដោយមនុស្ស និងលទ្ធផលគោលពីរ ក៏ដូចជាការអ៊ិនគ្រីបទាំងខ្សែអក្សរ និងតម្លៃគោលពីរ (ដូចជាឯកសារ)។