27 ਜੂਨ 2025·8 ਮਿੰਟ
ਅਦੀ ਸ਼ਾਮੀਰ ਦੀਆਂ ਉਪਲਬਧੀਆਂ: RSA, ਗੁਪਤ ਸਾਂਝ ਅਤੇ ਸੁਰੱਖਿਆ
ਅਦੀ ਸ਼ਾਮੀਰ ਦੇ RSA ਅਤੇ secret sharing ਦੇ ਮੁੱਖ ਵਿਚਾਰਾਂ ਦਾ ਅਨੁਸ਼ੀਲਨ ਕਰੋ ਅਤੇ ਜਾਣੋ ਕਿ ਸੋਹਣਾ ਗਣਿਤ ਅਸਲ-ਦੁਨੀਆ ਦੀ ਸੁਰੱਖਿਆ, ਜੋਖਮ, ਅਤੇ ਕੁੰਜੀ ਸੰਭਾਲ ਨੂੰ ਕਿਵੇਂ ਪ੍ਰਭਾਵਿਤ ਕਰਦਾ ਹੈ।
ਅਦੀ ਸ਼ਾਮੀਰ ਦੇ RSA ਅਤੇ secret sharing ਦੇ ਮੁੱਖ ਵਿਚਾਰਾਂ ਦਾ ਅਨੁਸ਼ੀਲਨ ਕਰੋ ਅਤੇ ਜਾਣੋ ਕਿ ਸੋਹਣਾ ਗਣਿਤ ਅਸਲ-ਦੁਨੀਆ ਦੀ ਸੁਰੱਖਿਆ, ਜੋਖਮ, ਅਤੇ ਕੁੰਜੀ ਸੰਭਾਲ ਨੂੰ ਕਿਵੇਂ ਪ੍ਰਭਾਵਿਤ ਕਰਦਾ ਹੈ।
ਅਦੀ ਸ਼ਾਮੀਰ ਉਹਨਾਂ ਕੁਝ ਖੋਜਕਾਰਾਂ ਵਿੱਚੋਂ ਇੱਕ ਹਨ ਜਿਨ੍ਹਾਂ ਦੇ ਵਿਚਾਰ ਕਾਗਜ਼ਾਂ ਜਾਂ ਕਾਨ਼ਫਰੰਸਾਂ ਤੱਕ ਹੀ ਸੀਮਿਤ ਨਹੀਂ ਰਹੇ—ਉਹ ਰੋਜ਼ਾਨਾ ਸੁਰੱਖਿਆ ਦੇ ਬੁਨਿਆਦੀ ਪੱਥਰ ਬਣ ਗਏ। ਜੇ ਤੁਸੀਂ ਕਦੇ HTTPS ਵਰਤੀ ਹੈ, ਸੌਫਟਵੇਅਰ ਅੱਪਡੇਟ ਦੀ ਜਾਂਚ ਕੀਤੀ ਹੈ, ਜਾਂ ਆਨਲਾਈਨ ਭਰੋਸੇ ਲਈ ਡਿਜੀਟਲ ਦਸਤਖਤ ਉਤੇ ਨਿਰਭਰ ਕੀਤਾ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਉਸ ਕੰਮ ਦਾ ਫ਼ਾਇਦਾ ਉਠਾਇਆ ਹੈ ਜੋ ਉਹਨਾਂ ਨੇ ਸੰਵਾਰਨ ਵਿੱਚ ਯੋਗਦਾਨ ਦਿੱਤਾ।
ਸ਼ਾਮੀਰ ਨੇ RSA ਦਾ ਸਹਿ-ਅਵਿਸਕਾਰ ਕੀਤਾ—ਇੱਕ ਪਬਲਿਕ-ਕੀ ਕ੍ਰਿਪਟੋਸਿਸਟਮ ਜਿਸ ਨੇ ਅਜਿਹੇ ਤਰੀਕੇ ਨਾਲ ਬੇਨਜੀਰ ਦਰਜੇ 'ਤੇ ਸੁਰੱਖਿਅਤ ਸੁਨੇਹੇ ਬੇਹਤਰੀਨ ਢੰਗ ਨਾਲ ਵਟਾਂਦਰੇ ਯੋਗ ਬਣਾਏ। ਉਨ੍ਹਾਂ ਨੇ Shamir’s Secret Sharing ਵੀ ਬਣਾਇਆ—ਇੱਕ ਤਰੀਕਾ ਜਿਸ ਨਾਲ ਇਕ ਗੁਪਤ ਚੀਜ਼ (ਜਿਵੇਂ ਕਿ ਇਕ ਕ੍ਰਿਪਟੋਗ੍ਰਾਫਿਕ ਕੀ) ਨੂੰ ਕਈ ਹਿੱਸਿਆਂ ਵਿੱਚ ਵੰਡਿਆ ਜਾਂਦਾ ਹੈ ਤਾਂ ਕਿ ਕੋਈ ਇਕ ਵਿਅਕਤੀ ਜਾਂ ਸਰਵਰ ਪੂਰੀ ਤਰ੍ਹਾਂ ਕੰਟਰੋਲ ਨਾ ਰੱਖ ਸਕੇ।
ਦੋਹਾਂ ਵਿਚਾਰਾਂ ਦੀ ਇਕ ਥੀਮ ਸਾਂਝੀ ਹੈ: ਸਾਫ਼-ਸੁਥਰਾ ਗਣਿਤੀਕ ਨਜ਼ਰੀਆ ਪ੍ਰਯੋਗਿਕ ਸੁਰੱਖਿਆ ਯੋਗਤਾਵਾਂ ਨੂੰ ਖੋਲ ਸਕਦਾ ਹੈ ਜੋ ਸੰਸਥਾਵਾਂ ਅਸਲੀ ਜ਼ਿੰਦਗੀ ਵਿੱਚ ਤਾਇਨਾਤ ਕਰ ਸਕਦੀਆਂ ਹਨ।
ਇਸ ਲੇਖ ਦਾ ਧਿਆਨ ਉਸ ਪੁਲ 'ਤੇ ਹੈ—ਸੋਹਣਾ ਸੰਕਲਪ ਤੋਂ ਉਹ ਟੂਲ ਜਿਹੜੇ ਅਸਲੀ ਸਿਸਟਮਾਂ ਦੀ ਸਹਾਇਤਾ ਕਰਦੇ ਹਨ। ਤੁਸੀਂ ਦੇਖੋਗੇ ਕਿ RSA ਨੇ ਕਿਵੇਂ ਦਸਤਖਤ ਅਤੇ ਸੁਰੱਖਿਅਤ ਸੰਪਰਕ ਨੂੰ ਯੋਗ ਬਣਾਇਆ, ਅਤੇ Shamir ਦੀ secret sharing ਨੇ ਕਿਵੇਂ "k-of-n" ਨਿਯਮਾਂ (ਉਦਾਹਰਣ ਲਈ ਕਿਸੇ 5 ਵਿੱਚੋਂ ਕਈ 3 ਹੋ ਕੇ ਮਹੱਤਵਪੂਰਨ ਕਾਰਵਾਈ ਨੂੰ ਮਨਜ਼ੂਰੀ ਦੇ ਸਕਦੇ ਹਨ) ਦੇ ਜ਼ਰੀਏ ਟੀਮਾਂ ਵਿਚ ਭਰੋਸਾ ਫੈਲਾਉਣ ਵਿੱਚ ਮਦਦ ਕੀਤੀ।
ਅਸੀਂ ਮੁੱਖ ਵਿਚਾਰ ਸਧਾਰਨ ਭਾਸ਼ਾ ਵਿੱਚ ਬਿਨਾਂ ਭਾਰੀ ਸਮੀਕਰਨਾਂ ਜਾਂ ਉੱਚ-ਦਰਜੇ ਦੇ ਨੰਬਰ ਸਿਧਾਂਤ ਦੇ ਸਮਰੱਥਾ ਦੇਵਾਂਗੇ। ਮਨੋਰਥ ਸਾਫ਼ ਹੈ: ਇਹ ਸਮਝਣਾ ਕਿ ਇਹ ਸਿਸਟਮ ਕੀ ਹਾਸਲ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰ ਰਹੇ ਹਨ, ਡਿਜ਼ਾਈਨ ਕਿਉਂ ਚਤੁਰ ਹੈ, ਅਤੇ ਕਿੱਥੇ ਖਤਰਨਾਕ ਧਾਰਾਂ ਹਨ।
ਪਰ ਹੱਦਾਂ ਹਨ। ਮਜ਼ਬੂਤ ਗਣਿਤ ਖੁਦ ਬੈਠ ਕੇ ਮਜ਼ਬੂਤ ਸੁਰੱਖਿਆ ਨਹੀਂ ਬਣਾਉਂਦਾ। ਅਸਲੀ ਟੁੱਟ-ਫੁੱਟ ਜ਼ਿਆਦਾਤਰ ਇੰਪਲਿਮੈਂਟੇਸ਼ਨ ਗਲਤੀਆਂ, ਖ਼ਰਾਬ ਕੁੰਜੀ ਪ੍ਰਬੰਧਨ, ਘੱਟਜ਼ੋਰ ਅਪਰੇਸ਼ਨਲ ਪ੍ਰਕਿਰਿਆਵਾਂ, ਜਾਂ ਖ਼ਤਰਨਾਕ ਪਰਕਿਰਿਆਵਾਂ ਦੀ ਅਨੁਮਾਨ ਲੈਣ ਨਾਲ ਹੁੰਦੀ ਹੈ। ਸ਼ਾਮੀਰ ਦਾ ਕੰਮ ਸਾਨੂੰ ਦੋਹਾਂ ਪਾਸੇ ਦੇਖਣ ਦੀ ਸਮਰੱਥਾ ਦਿੰਦਾ ਹੈ: ਚੰਗੇ ਕ੍ਰਿਪਟੋਗ੍ਰਾਫਿਕ ਡਿਜ਼ਾਈਨ ਦੀ ਤਾਕਤ—ਅਤੇ ਸੰਭਾਲਯੋਗ, ਪ੍ਰਯੋਗਿਕ ਕਾਰਜਾਵਾਈ ਦੀ ਲੋੜ।
ਇੱਕ ਅਸਲ ਕ੍ਰਿਪਟੋਗ੍ਰਾਫਿਕ ਉਨਤਿ ਸਿਰਫ਼ "ਅਸੀਂ ਇਨਕ੍ਰਿਪਸ਼ਨ ਤੇਜ਼ ਕਰ ਦਿੱਤੀ" ਨਹੀਂ ਹੁੰਦੀ। ਇਹ ਇੱਕ ਨਵੀਂ ਸਮਰੱਥਾ ਹੁੰਦੀ ਹੈ ਜਿਸ ਨਾਲ ਲੋਕ ਨਿਰਪੱਖ ਤੌਰ 'ਤੇ ਨਵੀਆਂ ਚੀਜ਼ਾਂ ਕੀਤੀ ਜਾ ਸਕਦੀਆਂ ਹਨ—ਖ਼ਾਸ ਕਰਕੇ ਵੱਡੇ ਪੈਮਾਨੇ 'ਤੇ, ਅਜਾਣੇ ਲੋਕਾਂ ਵਿੱਖੇ, ਅਤੇ ਅਸਲ-ਦੁਨੀਆ ਦੀਆਂ ਪਾਬੰਦੀਆਂ ਜਿਵੇਂ ਅਨਿਸ਼ਚਿਤ ਨੈੱਟਵਰਕ ਅਤੇ ਮਨੁੱਖੀ ਗਲਤੀਆਂ ਦੇ ਆਧਾਰ 'ਤੇ।
ਪੁਰਾਣੀਆਂ "ਰਹੱਸ ਕੋਡ" ਦਰੁਸਤੀ ਸੁਨੇਹੇ ਛੁਪਾਉਣ ’ਤੇ ਕੇਂਦਰਤ ਹੁੰਦੀਆ ਸਨ। ਆਧੁਨਿਕ ਕ੍ਰਿਪਟੋਗ੍ਰਾਫੀ ਵੱਧ ਵਿਸ਼ਤ লক্ষ্য ਰੱਖਦੀ ਹੈ:
ਇਹ ਬਦਲਾਅ ਮੁੱਤਲਕ ਹੈ ਕਿਉਂਕਿ ਬਹੁਤ ਸਾਰੀਆਂ ਨਾਕਾਮੀਆਂ ਸੁਨੇਹਾ ਚੋਰਾ ਕਰਨ ਦੀ ਬਜਾਏ ਛੇੜਛਾੜ, ਨਕਲ-ਬਨਣੀ, ਅਤੇ "ਕਿਸਨੇ ਕੀ ਕੀਤਾ" ਦੀਆਂ ਵਾਦ-ਵਿਵਾਦਾਂ ਨਾਲ ਸੰਬੰਧਤ ਹੁੰਦੀਆਂ ਹਨ।
ਸਿਮੇਟ੍ਰਿਕ ਕ੍ਰਿਪਟੋਗ੍ਰਾਫੀ ਵਿੱਚ ਦੋਹਾਂ ਪਾਸਿਆਂ ਕੋਲ ਇਕੋ ਹੀ ਗੁਪਤ ਕੁੰਜੀ ਹੁੰਦੀ ਹੈ। ਇਹ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਹੈ ਅਤੇ ਅਜੇ ਵੀ ਵਿਸ਼ਾਲ ਪੱਧਰ 'ਤੇ ਵਰਤੀ ਜਾਂਦੀ ਹੈ (ਉਦਾਹਰਣ ਲਈ, ਵੱਡੀ ਫਾਇਲਾਂ ਜਾਂ ਨੈੱਟਵਰਕ ਟ੍ਰੈਫਿਕ ਨੂੰ ਐਨਕ੍ਰਿਪਟ ਕਰਨਾ)। ਮੁਸ਼ਕਲ ਹਿੱਸਾ ਹੈ: ਕਿਵੇਂ ਦੋ ਪਾਰਟੀਆਂ ਉਹ ਕੁੰਜੀ ਸੁਰੱਖਿਅਤ ਢੰਗ ਨਾਲ ਸਾਂਝਾ ਕਰਨਗੀਆਂ—ਖ਼ਾਸ ਤੌਰ 'ਤੇ ਜੇ ਉਹ ਪਹਿਲਾਂ ਕਦੇ ਮਿਲੇ ਹੀ ਨਹੀਂ।
ਪਬਲਿਕ-ਕੀ ਕ੍ਰਿਪਟੋਗ੍ਰਾਫੀ ਕੁੰਜੀ ਨੂੰ ਦੋ ਹਿੱਸਿਆਂ ਵਿੱਚ ਵੰਡਦੀ ਹੈ: ਇੱਕ ਪਬਲਿਕ ਕੀ ਜੋ ਤੁਸੀਂ ਖੁੱਲ੍ਹਾ ਸਾਂਝਾ ਕਰ ਸਕਦੇ ਹੋ ਅਤੇ ਇੱਕ ਪ੍ਰਾਇਵੇਟ ਕੀ ਜੋ ਤੁਸੀਂ ਗੁਪਤ ਰੱਖਦੇ ਹੋ। ਲੋਕ ਤੁਹਾਡੇ ਪਬਲਿਕ ਕੀ ਨਾਲ ਤੁਹਾਨੂੰ ਸੁਨੇਹੇ ਭੇਜ ਸਕਦੇ ਹਨ ਜੋ ਕੇਵਲ ਤੁਹਾਡੀ ਪ੍ਰਾਇਵੇਟ ਕੀ ਹੀ ਖੋਲ ਸਕਦੀ ਹੈ। ਜਾ ਫਿਰ ਤੁਸੀਂ ਆਪਣੀ ਪ੍ਰਾਇਵੇਟ ਕੀ ਨਾਲ ਕਿਸੇ ਚੀਜ਼ 'ਤੇ ਸਾਈਨ ਕਰਦੇ ਹੋ ਤਾਂ ਹਰ ਕੋਈ ਤੁਹਾਡੇ ਪਬਲਿਕ ਕੀ ਨਾਲ ਉਸ ਦੀ ਜਾਂਚ ਕਰ ਸਕਦਾ ਹੈ।
ਜਦੋਂ ਪਬਲਿਕ ਕੀ ਪ੍ਰਾਇਕਟਿਕਲ ਹੋ ਗਿਆ, ਸੁਰੱਖਿਅਤ ਸੰਚਾਰ ਲਈ ਪਹਿਲਾਂ ਗੁਪਤ ਸਾਂਝਾ ਕਰਨ ਜਾਂ ਭਰੋਸੇਯੋਗ ਕੁਰਿਅਰ ਦੀ ਲੋੜ ਖ਼ਤਮ ਹੋ ਗਈ। ਇਸ ਨਾਲ ਇੰਟਰਨੈਟ-ਪੈਮਾਨੇ ਦੇ ਸਿਸਟਮ ਤੇਜ਼ੀ ਨਾਲ ਸੁਰੱਖਿਅਤ ਹੋਏ: ਸੁਰੱਖਿਅਤ ਲਾਗਿਨ, ਇੰਕ੍ਰਿਪਟਡ ਵੈੱਬ ਟ੍ਰੈਫਿਕ, ਜਿਨ੍ਹਾਂ ਅੱਪਡੇਟਾਂ ਦੀ ਤੁਸੀਂ ਜਾਂਚ ਕਰ ਸਕਦੇ ਹੋ, ਅਤੇ ਡਿਜੀਟਲ ਦਸਤਖਤ ਜੋ ਪਛਾਣ ਅਤੇ ਜ਼ਿੰਮੇਵਾਰੀ ਦਾ ਸਹਾਰਾ ਦਿੰਦੇ ਹਨ।
ਇਹਾਂ ਹੀ ਉਸ ਤਰ੍ਹਾਂ ਦੀ "ਨਵੀਂ ਸਮਰੱਥਾ" ਹੈ ਜੋ ਉਨਤਿ ਦਾ ਸਨਮਾਨ ਜਿੱਤਦੀ ਹੈ।
RSA ਦੀ ਸ਼ੁਰੂਆਤ ਦੀ ਇੱਕ ਵਧੀਆ ਕਹਾਣੀ ਹੈ: ਤਿੰਨ ਖੋਜਕਾਰ—Ron Rivest, Adi Shamir, ਅਤੇ Leonard Adleman—ਇੱਕ ਨਵੇਂ ਵਿਚਾਰ (ਪਬਲਿਕ-ਕੀ ਕ੍ਰਿਪਟੋਗ੍ਰਾਫੀ) ਨੂੰ ਅਸਲੀ ਵਰਤੋਂ ਯੋਗ ਬਣਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰ ਰਹੇ ਸਨ।
1977 ਵਿੱਚ, ਉਨ੍ਹਾਂ ਨੇ ਇੱਕ ਸਕੀਮ ਪ੍ਰਕਾਸ਼ਿਤ ਕੀਤੀ ਜੋ ਤੇਜ਼ੀ ਨਾਲ ਸਭ ਤੋਂ ਮਸ਼ਹੂਰ ਪ੍ਰਾਇਕਟਿਕਲ ਜਵਾਬ ਬਣ ਗਈ ਇਸ ਸਧਾਰਨ ਸਵਾਲ ਲਈ: “ਕਿਵੇਂ ਦੋ ਲੋਕ ਬਿਨਾਂ ਪਹਿਲਾਂ ਕਿਸੇ ਗੁਪਤ ਚੀਜ਼ ਨੂੰ ਸਾਂਝਾ ਕੀਤੇ ਸੁਰੱਖਿਅਤ ਤਰੀਕੇ ਨਾਲ ਗੱਲ ਕਰ ਸਕਦੇ ਹਨ?” ਉਨ੍ਹਾਂ ਦੇ ਨਾਮ ਅੈੱਕਰੋਨਿਮ ਵਿੱਚ ਆ ਗਏ—RSA।
RSA ਦਾ ਵੱਡਾ ਬਦਲਾਅ ਦੈਨੀਕ ਸ਼ਬਦਾਂ ਵਿੱਚ ਆਸਾਨੀ ਨਾਲ ਵਰਣਨ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਤੁਸੀਂ ਇੱਕ ਤਾਲਾ ਛਪਾ ਸਕਦੇ ਹੋ (ਤੁਹਾਡੀ ਪਬਲਿਕ ਕੀ) ਜੋ ਕੋਈ ਵੀ ਵਰਤ ਸਕਦਾ ਹੈ, ਜਦਕਿ ਉਸ ਨੂੰ ਖੋਲ੍ਹਣ ਵਾਲੀ ਇਕਲੌਤੀ ਕੁੰਜੀ ਤੁਹਾਡੇ ਕੋਲ ਰਹੇਗੀ (ਤੁਹਾਡੀ ਪ੍ਰਾਇਵੇਟ ਕੀ)।
ਜੇ ਕੋਈ ਤੁਹਾਨੂੰ ਸੁਰੱਖਿਅਤ ਸੁਨੇਹਾ ਭੇਜਣਾ ਚਾਹੁੰਦਾ ਹੈ, ਉਹ ਤੁਹਾਨੂੰ ਪਹਿਲਾਂ ਮਿਲਣ ਦੀ ਲੋੜ ਨਹੀਂ ਰੱਖਦਾ। ਉਹ ਤੁਹਾਡੇ ਪਬਲਿਕ ਤਾਲੇ ਨੂੰ ਲੈ ਕੇ ਸੁਨੇਹੇ 'ਤੇ ਲਾ ਦੇਂਦਾ ਹੈ ਅਤੇ ਲਾਕ ਕੀਤੇ ਡੱਬੇ ਨੂੰ ਭੇਜ ਦਿੰਦਾ ਹੈ। ਕੇਵਲ ਤੁਹਾਡੀ ਪ੍ਰਾਇਵੇਟ ਕੀ ਉਹ ਖੋਲ੍ਹ ਸਕਦੀ ਹੈ।
ਇਹ "ਤਾਲਾ ਛਪਾਓ, ਕੁੰਜੀ ਛੁਪਾਓ" ਦਾ ਵਾਅਦਾ ਹੀ RSA ਨੂੰ ਉਸ ਸਮੇਂ ਜਾਦੂਈ ਮਹਿਸੂਸ ਕਰਵਾਉਂਦਾ ਸੀ—ਅਤੇ ਇਸੇ ਕਾਰਨ ਇਹ ਇੰਟਰਨੈਟ 'ਤੇ ਆਧੁਨਿਕ ਭਰੋਸੇ ਦੀ ਨੀਵ ਬਣਿਆ।
RSA ਇਕ ਖਾਸ ਕਿਸਮ ਦੇ ਪਜ਼ਲ ਤੇ ਅਧਾਰਤ ਹੈ:
RSA ਵਿੱਚ, ਪਬਲਿਕ ਕੀ ਕਿਸੇ ਨੂੰ ਸੁਨੇਹਾ ਸੁਰੱਖਿਅਤ ਕਰਨ ਲਈ "ਰੰਗ ਮਿਲਾਉਣ" ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ, ਜਦਕਿ ਪ੍ਰਾਇਵੇਟ ਕੀ ਉਹ ਛੁਪਿਆ ਰੈਸੀਪੀ ਹੈ ਜੋ ਵਾਪਸੀ ਨੂੰ ਆਸਾਨ ਬਣਾਉਂਦੀ ਹੈ।
RSA ਕੁਝ ਮੁੱਖ ਭੂਮਿਕਾਵਾਂ ਵਿੱਚ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ:
ਜੇਕਰ ਨਵੇਂ ਸੰਦ ਪ੍ਰਚਲਿਤ ਹੋਏ ਹਨ, ਫਿਰ ਵੀ RSA ਦਾ ਆਮ-ਭਾਸ਼ਾ ਵਾਲਾ ਵਿਚਾਰ—ਪਬਲਿਕ ਤਾਲਾ, ਪ੍ਰਾਇਵੇਟ ਕੁੰਜੀ—ਅਜੇ ਵੀ ਇੰਟਰਨੈਟ 'ਤੇ ਭਰੋਸਾ ਕਿਵੇਂ ਬਣਦਾ ਹੈ ਇਹ ਬਹੁਤ ਕੁਝ ਸਮਝਾਉਂਦਾ ਹੈ।
RSA ਅਜਿਹਾ ਨਹੀਂ ਲੱਗਦਾ ਜਦ ਤੱਕ ਤੁਸੀਂ ਦੋ ਆਮ ਧਾਰਨਾਂ 'ਤੇ ਗੰਭੀਰਤਾ ਨਾਲ ਨਹੀਂ ਦੇਖਦੇ: ਨੰਬਰਾਂ ਨੂੰ ਇੱਕ ਨਿਰਧਾਰਤ ਰੇਂਜ਼ ਵਿੱਚ ਲਪੇਟਣਾ ਅਤੇ ਇੱਕ ਅਜਿਹਾ ਸਮੱਸਿਆ ਜਿਸਨੂੰ ਉਲਟਣਾ ਬਹੁਤ ਧੀਮਾ ਲੱਗਦਾ ਹੈ।
ਮੋਡਿਊਲਰ ਅਰਿਥਮੈਟਿਕ ਉਹ ਹੁੰਦਾ ਹੈ ਜਦ ਨੰਬਰ "ਲੁੱਟ ਰਹੇ" ਹੁੰਦੇ ਹਨ, ਜਿਵੇਂ ਘੜੀ ਤੇ ਘੰਟੇ। 12-ਘੰਟੇ ਦੀ ਘੜੀ 'ਤੇ, 10 + 5 = 3 ਹੁੰਦਾ ਹੈ।
RSA ਇਸੇ ਲੁਪ-ਆਲੇ ਵਿਚਾਰ ਨੂੰ ਵਰਤਦਾ ਹੈ, ਸਿਰਫ਼ ਬਹੁਤ ਵੱਡੀ "ਘੜੀ" ਨਾਲ। ਤੁਸੀਂ ਇੱਕ ਵੱਡਾ ਨੰਬਰ (modulus) ਚੁਨਦੇ ਹੋ ਅਤੇ ਉਹਨਾਂ ਗਣਨਾਵਾਂ 'ਚ ਨਤੀਜੇ ਹਮੇਸ਼ਾ 0 ਤੋਂ modulus-1 ਤੱਕ ਦੀ ਰੇਂਜ਼ ਵਿੱਚ ਘੱਟ ਕੀਤੇ ਜਾਂਦੇ ਹਨ।
ਇਸਦਾ ਮਹੱਤਵ ਇਹ ਹੈ: ਮੋਡਿਊਲਰ ਅੰਕਗਣਿਤ ਕੁਝ ਆਪਰੇਸ਼ਨਾਂ ਨੂੰ ਇੱਕ ਦਿਸ਼ਾ ਵਿੱਚ ਆਸਾਨ ਬਣਾਉਂਦਾ ਹੈ, ਜਦਕਿ ਉਲਟ ਦਿਸ਼ਾ ਮੁਸ਼ਕਲ ਰੱਖਦਾ ਹੈ—ਹੀ ਉਹ ਅਸਥਿਰਤਾ ਜੋ ਕ੍ਰਿਪਟੋਗ੍ਰਾਫੀ ਚਾਹੁੰਦੀ ਹੈ।
ਕ੍ਰਿਪਟੋਗ੍ਰਾਫੀ ਆਮ ਤੌਰ 'ਤੇ ਇਕ ਟਾਸਕ 'ਤੇ ਨਿਰਭਰ ਕਰਦੀ ਹੈ ਜੋ:
RSA ਲਈ, "ਖ਼ਾਸ ਜਾਣਕਾਰੀ" ਪ੍ਰਾਇਵੇਟ ਕੀ ਹੈ। ਇਸ ਦੇ ਬਿਨਾਂ, ਹਮਲਾਵਰ ਇੱਕ ਐਸੀ ਸਮੱਸਿਆ ਦਾ ਸਾਹਮਣਾ ਕਰਦਾ ਹੈ ਜੋ ਅਤਿ ਮਹਿੰਗੀ ਮਹਿਸੂਸ ਹੁੰਦੀ ਹੈ।
RSA ਦੀ ਸੁਰੱਖਿਆ ਉਸ ਗਠਜੋੜ 'ਤੇ ਨਿਰਭਰ ਕਰਦੀ ਹੈ ਜੋ ਫੈਕਟਰਿੰਗ कहलਾਉਂਦੀ ਹੈ: ਇਕ ਵੱਡਾ ਨੰਬਰ ਲੈਕੇ ਉਸ ਦੇ ਦੋ ਵੱਡੇ ਪ੍ਰਾਇਮ ਨੰਬਰ ਲੱਭਣਾ ਜਿਹੜੇ ਉਸਨੂੰ ਬਣਾਉਂਦੇ ਹਨ।
ਦੋ ਵੱਡੇ ਪ੍ਰਾਇਮਾਂ ਨੂੰ ਗੁਣਾ ਕਰਨਾ ਸਿੱਧਾ ਹੈ। ਪਰ ਜੇ ਕੋਈ ਤੁਹਾਡੇ ਕੋਲ ਸਿਰਫ ਉਤਪਾਦ ਦਿੱਤਾ ਹੋਵੇ ਅਤੇ ਪੁੱਛੇ ਕਿ ਅਸਲੀ ਪ੍ਰਾਇਮ ਕੀ ਹਨ, ਤਾਂ ਉਹ ਊਲਟ ਕਦਮ ਜ਼ਿਆਦਾ ਮਹਿੰਗਾ ਮਹਿਸੂਸ ਹੁੰਦਾ ਹੈ ਜਿਵੇਂ ਨੰਬਰ ਵਧਦੇ ਹਨ।
ਇਹੀ ਫੈਕਟੋ੍ਰਿੰਗ ਦੀ ਮੁਸ਼ਕਲਤਾ RSA ਨੂੰ ਕੰਮਯਾਬ ਬਣਾਉਂਦੀ ਹੈ: ਪਬਲਿਕ ਜਾਣਕਾਰੀ ਸਾਂਝੀ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਜਦਕਿ ਪ੍ਰਾਇਵੇਟ ਕੀ ਵਰਤਣ ਵਿੱਚ ਪ੍ਰਯੋਗਕ ਤੇਜ਼ ਹੁੰਦੀ ਹੈ ਪਰ ਦੁਬਾਰਾ ਰੀਕਨਸਟਰਕਟ ਕਰਨਾ ਮੁਸ਼ਕਲ।
RSA ਕਿਸੇ ਗਣਿਤੀਕ ਸਬੂਤ ਨਾਲ ਇਹ ਸਾਬਤ ਨਹੀਂ ਕਿ ਫੈਕਟਰਿੰਗ ਅਸੰਭਵ ਹੈ। ਇਹ ਦਹਾਕਿਆਂ ਦੀ ਸਬੂਤ-ਜਾਂਚ ਤੇ ਨਿਰਭਰ ਹੈ: ਹੋਸ਼ਿਆਰ ਖੋਜਕਾਰਾਂ ਨੇ ਕਈ ਤਰੀਕੇ ਕੋਸ਼ਿਸ਼ ਕੀਤੇ, ਅਤੇ ਸਭ ਤੋਂ ਚੰਗੇ ਪਤਾ ਲੱਗੇ ਤਰੀਕੇ ਵੀ ਠੀਕ ਆਕਾਰ ਦੀ ਚাবੀ ਦੇ ਸਮੇਂ ਵਿੱਚ ਬਹੁਤ ਲੰਮੇ ਲੱਗਦੇ ਹਨ।
ਇਸ ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਇਹ "ਮੰਨਿਆ ਹੋਇਆ ਮੁਸ਼ਕਲ" ਹੈ: ਸਦੀਵੀ ਨਹੀਂ, ਪਰ ਭੇਦਣਾ ਚੀਜ਼ ਕੋਈ ਵੱਡੀ ਨਵੀਂ ਖੋਜ ਮੰਗਦਾ ਹੈ।
ਕੁੰਜੀ-ਆਕਾਰ ਉਸ ਮੋਡਿਊਲਰ "ਘੜੀ" ਦੀ ਮਿਤੀ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ। ਵੱਡੀਆਂ ਚਾਬੀਆਂ ਆਮ ਤੌਰ 'ਤੇ ਫੈਕਟਰਿੰਗ ਨੂੰ ਨਾਟਕੀ ਤੌਰ 'ਤੇ ਮਹਿੰਗਾ ਬਣਾਉਂਦੀਆਂ ਹਨ, ਜਿਸ ਨਾਲ ਹਮਲੇ ਅਸੰਭਵ ਸਮੇਂ ਅਤੇ ਬਜਟ ਦੇ ਪਰੇ ਹੋ ਜਾਂਦੇ ਹਨ। ਇਸੀ ਲਈ ਪੁਰਾਣੀਆਂ ਛੋਟੀ RSA ਚਾਬੀਆਂ ਬੰਦ ਕਰ ਦਿੱਤੀਆਂ ਗਈਆਂ—ਅਤੇ ਇਸੀ ਲਈ ਕੁੰਜੀ ਦੀ ਲੰਬਾਈ ਚੁਣਨਾ ਅਸਲ ਵਿੱਚ ਹਮਲਾਵਰ ਦੀ ਮਿਹਨਤ ਬਾਰੇ ਫੈਸਲਾ ਹੈ।
ਡਿਜੀਟਲ ਦਸਤਖਤ ਇਕ ਵੱਖਰਾ ਸਵਾਲ ਦਾ ਜਵਾਬ ਦਿੰਦੇ ਹਨ ਬਨਾਲੀਪਤਾ ਨੂੰ ਸ਼ੁੱਧ ਕਰਦੇ ਹਨ। ਇਨਕ੍ਰਿਪਸ਼ਨ ਰੱਖਿਆ ਕਰਦਾ ਹੈ: "ਕੇਵਲ ਨਿਸ਼ਚਿਤ ਪ੍ਰਾਪਤਕਰਤਾ ਹੀ ਇਹ ਪੜ੍ਹ ਸਕੇ?" ਦਸਤਖਤ ਭਰੋਸਾ ਰੱਖਦਾ ਹੈ: "ਕਿਸ ਨੇ ਇਹ ਬਣਾਇਆ, ਅਤੇ ਕੀ ਇਹ ਬਦਲਿਆ ਗਿਆ?"
ਇੱਕ ਡਿਜੀਟਲ ਸਿਗਨੇਚਰ ਆਮ ਤੌਰ 'ਤੇ ਦੋ ਗੱਲਾਂ ਸਾਬਤ ਕਰਦਾ ਹੈ:
RSA ਨਾਲ, ਸਾਇਨ ਕਰਨ ਵਾਲਾ ਆਪਣੀ ਪ੍ਰਾਇਵੇਟ ਕੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਸੁਨੇਹੇ ਨਾਲ ਜੁੜਿਆ ਇੱਕ ਛੋਟਾ ਡੇਟਾ-ਟੁਕੜਾ—ਸਿਗਨੇਚਰ—ਤਿਆਰ ਕਰਦਾ ਹੈ। ਕਿਸੇ ਵੀ ਵਿਅਕਤੀ ਕੋਲ ਮਿਲਦਾ ਪਬਲਿਕ ਕੀ ਉਹਨਾਂ ਲਈ ਇਸ ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ ਕਾਫ਼ੀ ਹੁੰਦੀ ਹੈ।
ਜਰੂਰੀ ਗੱਲ: ਤੁਸੀਂ ਸਿੱਧਾ "ਸਾਰੀ ਫਾਇਲ" ਨੂੰ ਸਾਈਨ ਨਹੀਂ ਕਰਦੇ। ਹਕੀਕਤ ਵਿੱਚ, ਸਿਸਟਮ ਇੱਕ ਹੈਸ਼ (ਫਾਇਲ ਦਾ ਸੰਕੁਚਿਤ ਫਿੰਗਰਪ੍ਰਿੰਟ) ਨੂੰ ਸਾਈਨ ਕਰਦੇ ਹਨ। ਇਸੀ ਲਈ ਸਾਈਨਿੰਗ ਇੱਕ ਛੋਟੀ ਸੁਨੇਹਾ ਜਾਂ ਇੱਕ ਬਹੁਤ ਵੱਡੀ ਫਾਈਲ ਦੋਹਾਂ ਲਈ ਕੁਸ਼ਲ ਕੰਮ ਕਰਦੀ ਹੈ।
RSA ਦਸਤਖਤ ਉਸ ਜਗ੍ਹਾ ਤੇ ਨਜ਼ਰ ਆਉਂਦੇ ਹਨ ਜਿਥੇ ਪਿਆਸ —ਸਮੇਤ— ਪਛਾਣ ਦੀ ਜਾਂਚ ਪੈਮਾਨੇ 'ਤੇ ਲੱਭਦੀ ਹੈ:
ਸਧਾਰਨ ਤੌਰ 'ਤੇ "RSA ਗਣਿਤ ਕਰਨਾ" ਕਾਫ਼ੀ ਨਹੀਂ ਹੈ। ਅਸਲੀ ਦੁਨੀਆ ਵਾਲੇ RSA ਦਸਤਖਤ ਮਿਆਰੀ ਪੈਡਿੰਗ ਅਤੇ ਏਨਕੋਡਿੰਗ ਨਿਯਮਾਂ ਉੱਤੇ ਨਿਰਭਰ ਕਰਦੇ ਹਨ (ਜਿਵੇਂ PKCS#1 ਜਾਂ RSA-PSS). ਇਹਨਾਂ ਨੂੰ ਉਹਨਾਂ ਗਾਰਡਰੇਲਸ ਸਮਝੋ ਜੋ ਨਾਜ਼ੁਕ ਹਮਲਿਆਂ ਤੋਂ ਬਚਾਉਂਦੇ ਹਨ ਅਤੇ ਦਸਤਖਤ ਨੂੰ ਸਪਸ਼ਟ ਰੂਪ ਦਿੰਦੇ ਹਨ।
ਤੁਸੀਂ ਬਿਨਾਂ ਭੇਜਕਰਤਾ ਸਾਬਤ ਕੀਤੇ ਇਨਕ੍ਰਿਪਟ ਕਰ ਸਕਦੇ ਹੋ, ਅਤੇ ਤੁਸੀਂ ਛੁਪਾਉਣ ਬਿਨਾਂ ਦਸਤਖਤ ਕਰ ਸਕਦੇ ਹੋ। ਬਹੁਤ ਸਾਰੇ ਸੁਰੱਖਿਅਤ ਸਿਸਟਮ ਦੋਹਾਂ ਕਰਦੇ ਹਨ—ਪਰ ਉਹ ਵੱਖ-ਵੱਖ ਸਮੱਸਿਆਵਾਂ ਹੱਲ ਕਰਦੇ ਹਨ।
RSA ਇੱਕ ਮਜ਼ਬੂਤ ਵਿਚਾਰ ਹੈ, ਪਰ ਜ਼ਿਆਦਾਤਰ ਅਸਲੀ ਦੁਨੀਆ ਦੀਆਂ "ਟੁੱਟੀਆਂ" ਅਧਾਰ ਗਣਿਤ ਨੂੰ ਹਰਾਇਆ ਨਹੀਂ ਕਰਦੀਆਂ। ਉਹ ਉਸ ਦੇ ਆਲੇ-ਦੁਆਲੇ ਦੇ ਗੰਦੇ ਹਿੱਸਿਆਂ ਤੋਂ ਫ਼ਾਇਦਾ ਉਠਾਉਂਦੀਆਂ ਹਨ: ਕਿਵੇਂ ਕੁੰਜੀਆਂ ਬਣਾਈਆਂ ਜਾਂਦੀਆਂ ਹਨ, ਸੁਨੇਹਿਆਂ ਨੂੰ ਪੈਡ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਡਿਵਾਈਸ ਵਤੀਵਕ ਕਰਦਾ ਹੈ, ਅਤੇ ਲੋਕ ਸਿਸਟਮ ਚਲਾਉਂਦੇ ਹਨ।
ਜਦੋਂ ਖਬਰਾਂ ਵਿੱਚ ਕਿਹਾ ਜਾਂਦਾ ਹੈ "RSA ਟੁੱਟ ਗਿਆ", ਉਹ ਅਕਸਰ ਕਿਸੇ ਇੰਪਲਿਮੈਂਟੇਸ਼ਨ ਗਲਤੀ ਜਾਂ ਤਜਵੀਜ਼ੀ ਛੋਟ ਦੇ ਬਾਰੇ ਹੁੰਦੀ ਹੈ। RSA ਹੁੰਦਾ ਹੈ ਕਿ ਹੁਣ ਧੁੱਸੇ "ਰਾਅ RSA" ਵਜੋਂ ਘੱਟ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ; ਇਹ ਪ੍ਰੋਟੋਕਾਲਾਂ ਵਿੱਚ ਇੰਬੈੱਡ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਪੈਡਿੰਗ ਸਕੀਮਾਂ ਨਾਲ ਘੇਰਿਆ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਹੈਸ਼ਿੰਗ ਅਤੇ randomness ਨਾਲ ਮਿਲਾਇਆ ਜਾਂਦਾ ਹੈ। ਜੇ ਉਹਨਾਂ ਵਿਚੋਂ ਕੋਈ ਭੀ ਹਿੱਸਾ ਗਲਤ ਹੋਵੇ, ਤਾਂ ਸਿਸਟਮ ਝੱਲ ਸਕਦਾ ਹੈ ਭਾਵੇਂ ਆਧਾਰਕ ਅਲਗੋਰਿਦਮ ਸਹੀ ਹੀ ਰਹੇ।
ਹੇਠਾਂ ਉਹ ਕਿਸਮਾਂ ਹਨ ਜੋ ਅਕਸਰ ਘਟਨਾਵਾਂ ਦਾ ਕਾਰਨ ਬਣਦੀਆਂ ਹਨ:
ਆਧੁਨਿਕ crypto ਲਾਇਬਰੇਰੀਆਂ ਅਤੇ ਮਿਆਰੀ ਇਸ ਲਈ ਮੌਜੂਦ ਹਨ ਕਿਉਂਕਿ ਟੀਮਾਂ ਨੇ ਇਹ ਸਬਕ ਸਖਤ ਤਰੀਕੇ ਨਾਲ ਸਿੱਖਿਆ। ਉਹ ਸੁਰੱਖਿਅਤ ਡੀਫਾਲਟ, constant-time ਆਪਰੇਸ਼ਨ, ਜਾਚ ਕੀਤੀ ਪੈਡਿੰਗ, ਅਤੇ ਪ੍ਰੋਟੋਕਾਲ-ਤਲ ਦੇ ਗਾਰਡਰੇਲ ਨੂੰ ਸ਼ਾਮِل ਕਰਦੇ ਹਨ। "ਆਪਣਾ RSA ਬਣਾਉਣਾ" ਜਾਂ ਮੰਨੀ ਹੋਈ ਸਕੀਮਾਂ ਚੇ ਛੇੜ-ਛਾੜ ਖਤਰਨਾਕ ਹੈ ਕਿਉਂਕਿ ਛੋਟੇ ਤਫ਼ਤੀਲ ਨਵੇਂ ਹਮਲੇ ਦੇ ਰਸਤੇ ਖੋਲ ਦੇਂਦੇ ਹਨ।
ਇਹ ਉਹਨਾਂ ਟੀਮਾਂ ਲਈ ਹੋਰ ਵੀ ਅਹਮ ਹੈ ਜੋ ਤੇਜ਼ੀ ਨਾਲ ਸ਼ਿਪ ਕਰ ਰਹੇ ਹਨ। ਜੇ ਤੁਸੀਂ ਇੱਕ ਤੁਰੰਤ ਵਿਕਾਸ ਵਰਕਫਲੋ ਵਰਤ ਰਹੇ ਹੋ—ਚਾਹੇ ਪਰੰਪਰਾਗਤ CI/CD ਹੋਵੇ ਜਾਂ vibe-coding ਪਲੇਟਫਾਰਮ ਵਰਗਾ Koder.ai—ਤੇਜ਼ੀ ਲਾਭ ਤਦ ਹੀ ਬਣੀ ਰਹਿੰਦੀ ਹੈ ਜਦੋਂ ਸੁਰੱਖਿਆ ਡੀਫਾਲਟ ਵੀ ਮਿਆਰੀ ਹੋਣ। Koder.ai ਦੀ ਯੋਗਤਾ ਕਿ ਇਹ React (ਵੈੱਬ), Go + PostgreSQL (ਬੈਕਏਂਡ), Flutter (ਮੋਬਾਈਲ) ਵਰਗੀ ਪੂਰਾ-ਸਟੈਕ ਐਪ ਤਿਆਰ ਅਤੇ ਡਿਪਲੋਯ ਕਰ ਸਕਦੀ ਹੈ, ਪਰ ਤੁਹਾਨੂੰ ਫਿਰ ਵੀ ਕੁੰਜੀ ਸੰਭਾਲ: TLS ਸਰਟੀਫਿਕੇਟ, ਸੀਕ੍ਰੇਟ ਮੈਨੇਜਮੈਂਟ, ਅਤੇ ਰਿਲੀਜ਼ ਸਾਈਨਿੰਗ ਨੂੰ ਪਹਿਲੀ-ਕਲਾਸ ਓਪਰੇਸ਼ਨਲ ਆਇਟਮ ਸਮਝ ਕੇ ਸੰਭਾਲਣਾ ਹੋਵੇਗਾ।
ਅਗਰ ਤੁਸੀਂ ਗਣਿਤ ਤੋਂ ਬਾਹਰ ਹੋਰ ਵਿਕਤ ਸੁਰੱਖਿਆ ਮਾਰਗਦਰਸ਼ਨ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ blog ਵਿੱਚ ਸੰਬੰਧਤ ਗਾਈਡਾਂ ਵੇਖੋ।
ਇੱਕ "ਮਾਸਟਰ ਸੀਕ੍ਰੇਟ" 'ਤੇ ਨਿਰਭਰਤਾ ਸੁਰੱਖਿਆ ਚਲਾਉਣ ਲਈ ਅਸੁਖਦਾਇਕ ਹੈ। ਜੇ ਇਕ ਵਿਅਕਤੀ ਕੋਲ ਕੁੰਜੀ ਹੈ (ਜਾਂ ਇਕ ਡਿਵਾਈਸ ਤੇ ਇਹ ਸਟੋਰ ਹੈ), ਤਾਂ ਤੁਸੀਂ ਆਮ ਜ਼ਿੰਦਗੀ ਦੀਆਂ ਵਿਫਲਤਾਵਾਂ ਲਈ ਖੁੱਲ੍ਹੇ ਹੋ: ਅਕਸਮੀਕ ਨੁਕਸਾਨ, ਚੋਰੀ, ਇਨਸਾਈਡਰ ਦੁਪੱਖਤਾ, ਜਾਂ ਬਲ-ਜਬਰ। ਗੁਪਤ ਚੀਜ਼ ਚੰਗੀ ਤਰ੍ਹਾਂ ਇਨਕ੍ਰਿਪਟ ਕੀਤੀ ਹੋ ਸਕਦੀ ਹੈ, ਪਰ ਫਿਰ ਵੀ ਨਾਜ਼ੁਕ ਰਹਿ ਜਾਂਦੀ ਹੈ ਕਿਉਂਕਿ ਉਸ ਦੀ ਇਕ ਇਕਲੌਤੀ ਮਾਲਕੀ ਹੁੰਦੀ ਹੈ।
Shamir ਦੀ Secret Sharing ਇਸ ਨੂੰ ਹੱਲ ਕਰਦੀ ਹੈ ਕਿ ਇੱਕ ਗੁਪਤ ਨੂੰ n ਵੱਖ-ਵੱਖ ਸ਼ੇਅਰਾਂ ਵਿੱਚ ਵੰਡ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ ਅਤੇ ਇਹ ਨਿਯਮ ਰੱਖਦੀ ਹੈ ਕਿ ਕੋਈ ਵੀ k ਸ਼ੇਅਰਾਂ ਨਾਲ ਮੂਲ ਗੁਪਤ ਮੁੜ ਬਣਾਇਆ ਜਾ ਸਕਦਾ ਹੈ—ਜਦਕਿ k ਤੋਂ ਘੱਟ ਕੁਝ ਵੀ ਉਪਯੋਗੀ ਜਾਣਕਾਰੀ ਨਹੀਂ ਦਿੰਦੇ।
ਇਸ ਤਰ੍ਹਾਂ "ਮਾਸਟਰ ਪਾਸਵਰਡ ਕਿਸ ਦੇ ਕੋਲ ਹੈ?" ਦੀ ਜਗ੍ਹਾ ਸਵਾਲ ਬਣਦਾ ਹੈ: "ਕੀ ਅਸੀ ਅਸਲੀ ਵਿੱਚ ਓਸ ਵੇਲੇ k ਅਧਿਕਾਰਤ ਲੋਕ/ਡਿਵਾਈਸ ਇਕੱਠੇ ਕਰ ਸਕਦੇ ਹਾਂ?"
ਥ੍ਰੈਸ਼ਹੋਲਡ ਸੁਰੱਖਿਆ ਭਰੋਸਾ ਨੂੰ ਕਈ ਰੱਖਣ ਵਾਲਿਆਂ ਵਿੱਚ ਫੈਲਾਉਂਦੀ ਹੈ:
ਇਹ ਉਹਨਾਂ ਉੱਚ-ਪ੍ਰਭਾਵ ਵਾਲੀਆਂ ਕੁੰਜੀਆਂ ਲਈ ਵਖਰੀ ਕੀਮਤ ਵਾਲੀ ਹੈ ਜਿਵੇਂ ਕਿ recovery keys, certificate authority ਸਮੱਗਰੀ, ਜਾਂ ਮਹੱਤਵਪੂਰਨ ਬੁਨਿਆਦੀ ਢਾਂਚੇ ਦੀ ਰੂਟ ਕ੍ਰੈਡੈਂਸ਼ਲ।
Shamir ਦੀ ਸੂਝ-ਬੂਝ ਸਿਰਫ ਗਣਿਤੀਕ ਸੋਹਣਪ ਨਹੀਂ ਸੀ—ਇਹ ਭਰੋਸਾ ਨੂੰ ਇਕ ਇਕੱਲੀ ਸ਼ਰਤ ਤੋਂ ਇਨਸਪੈਕਸ਼ਨਯੋਗ ਨਿਯਮ ਵਿੱਚ ਬਦਲਣ ਦਾ ਵਰਤੋਂਯੋਗ ਤਰੀਕਾ ਸੀ।
Shamir ਦੀ Secret Sharing ਇਕ ਬਹੁਤ ਅਮਲੀ ਸਮੱਸਿਆ ਹੱਲ ਕਰਦੀ ਹੈ: ਤੁਸੀਂ ਨਹੀਂ ਚਾਹੁੰਦੇ ਕਿ ਇੱਕ ਵਿਅਕਤੀ, ਇੱਕ ਸਰਵਰ, ਜਾਂ ਇਕ ਯੂਐਸਬੀ ਸਟਿਕ ਹੀ "ਕੀ" ਹੋਵੇ। ਇਸਦੀ ਥਾਂ, ਤੁਸੀਂ ਗੁਪਤ ਨੂੰ ਉਸੇ ਤਰ੍ਹਾਂ ਵੰਡ ਦਿੰਦੇ ਹੋ ਤਾਂ ਕਿ ਇੱਕ ਗਰੁੱਪ ਨੂੰ ਮਿਲਕੇ ਹੀ ਉਹ ਮੁੜ ਬਣ ਸਕੇ।
ਕਲਪਨਾ ਕਰੋ ਕਿ ਤੁਸੀਂ ਗਰਾਫ ਪੇਪਰ 'ਤੇ ਇੱਕ ਮਰਮਰ ਕਰਵ ਰੇਖਾ ਖਿੱਚ ਸਕਦੇ ਹੋ। ਜੇ ਤੁਹਾਨੂੰ ਉਸ ਰੇਖਾ ਦੇ ਇਕ ਜਾਂ ਦੋ ਬਿੰਦੂ ਹੀ ਦਿੱਤੇ ਜਾਣ, ਤਾਂ ਉਹਨਾਂ ਰਾਹੀਂ ਲੰਭੇ-ਲੰਭੇ ਕਈ ਰੇਖਾਵਾਂ ਖਿੱਚੀਆਂ ਜਾ ਸਕਦੀਆਂ ਹਨ। ਪਰ ਜੇ ਤੁਹਾਨੂੰ ਕਾਫੀ ਬਿੰਦੂ ਦਿੱਤੇ ਜਾਣ, ਤਾਂ ਰੇਖਾ ਇਕਲੌਤੀ ਤੌਰ 'ਤੇ ਨਿਰਧਾਰਤ ਹੋ ਜਾਂਦੀ ਹੈ।
ਇਹੀ polynomial interpolation ਦਾ ਮੁੱਖ ਵਿਚਾਰ ਹੈ: Shamir ਗੁਪਤ ਨੂੰ ਇੱਕ ਰੇਖਾ ਦੇ ਹਿੱਸੇ ਵਜੋਂ ਇੰਕੋਡ ਕਰਦਾ ਹੈ, ਫਿਰ ਉਸ ਰੇਖਾ ਦੇ ਬਿੰਦੂ ਲੋਕਾਂ ਨੂੰ ਵੰਡਦਾ ਹੈ। ਕਾਫੀ ਬਿੰਦੂ ਮਿਲਣ 'ਤੇ ਤੁਸੀਂ ਰੇਖਾ ਦੁਬਾਰਾ ਬਣਾਕੇ ਗੁਪਤ ਪੜ੍ਹ ਸਕਦੇ ਹੋ। ਘੱਟ ਬਿੰਦੂ ਹੋਣ ਨਾਲ ਤੁਹਾਡੇ ਕੋਲ ਬਹੁਤ ਸਾਰੀਆਂ ਸੰਭਵ ਰੇਖਾਵਾਂ ਰਹਿ ਜਾਂਦੀਆਂ ਹਨ—ਅਤੇ ਗੁਪਤ ਛੁਪਿਆ ਰਹਿੰਦਾ ਹੈ।
ਇੱਕ share ਉਸ ਲੁਕਾਈ ਰੇਖਾ ਦਾ ਸਿਰਫ਼ ਇਕ ਬਿੰਦੂ ਹੁੰਦਾ ਹੈ: ਇਕ ਛੋਟਾ ਡਾਟਾ ਪੈਕੇਟ ਜੋ ਖੁਦ ਵਿੱਚ ਵੇਖਣ 'ਤੇ ਰੈਨਡਮ ਲੱਗਦਾ ਹੈ।
ਯੋਜਨਾ ਆਮ ਤੌਰ 'ਤੇ k-of-n ਵਜੋਂ ਵਰਣਤ ਕੀਤੀ ਜਾਂਦੀ ਹੈ:
Secret sharing ਤਾਂ ਹੀ ਕੰਮ ਕਰਦੀ ਹੈ ਜਦ shares ਇੱਕੋ ਥਾਂ ਜਾਂ ਇੱਕੋ ਕੰਟਰੋਲ ਹੇਠ ਨਹੀਂ ਆਉਂਦੇ। ਚੰਗੀ ਅਭਿਆਸ ਇਹ ਹੈ ਕਿ ਉਹਨਾਂ ਨੂੰ ਲੋਕਾਂ, ਡਿਵਾਈਸਾਂ, ਅਤੇ ਥਾਵਾਂ 'ਚ ਵੰਡਿਆ ਜਾਵੇ (ਉਦਾਹਰਨ ਲਈ: ਇਕ ਹਾਰਡਵੇਅਰ ਟੋਕਨ ਵਿੱਚ ਇੱਕ, ਕਾਨੂੰਨੀ ਸਲਾਹਕਾਰ ਕੋਲ ਇੱਕ, ਇਕ ਸੁਰੱਖਿਅਤ ਵੌਲਟ ਵਿੱਚ ਇੱਕ)।
k ਚੁਣਨਾ ਇੱਕ ਸੰਤੁਲਨ ਹੈ:
ਸੌੰਦਰਿਆ ਇਹ ਹੈ ਕਿ ਗਣਿਤ ਸਾਫ਼ ਤਰੀਕੇ ਨਾਲ "ਵੰਡਿਆ ਭਰੋਸਾ" ਇੱਕ ਨਪੈ-ਸਹੀ ਨਿਯਮ ਵਿੱਚ ਬਦਲ ਦਿੰਦਾ ਹੈ।
Secret sharing ਨੂੰ ਸਾਰੇ ਹਾਲਾਤਾਂ ਵਿੱਚ "ਗੁਪਤ ਸੁਰੱਖਿਆ" ਵਜੋਂ ਨਹੀਂ ਵੇਖਣਾ ਚਾਹੀਦਾ—ਇਹ ਇੱਕ ਗਵਰਨੈਂਸ ਟੂਲ ਹੈ: ਤੁਸੀਂ ਜਾਣਬੂਝਕੇ ਬਹੁ-ਪੱਖੀ ਸਹਿਯੋਗ ਦੀ ਲੋੜ ਰੱਖਦੇ ਹੋ ਤਾਂ ਕਿ ਕਿਸੇ ਵੀ ਵਾਰ ਗੁਪਤ ਸੁਟੇਰਾ ਨਾ ਹੋਣਾ।
ਇਹ ਟੂਲ ਇੱਕੋ ਜਿਹੇ ਨਹੀਂ ਹਨ, ਹਾਲਾਂਕਿ ਸਾਰੇ ਜੋਖਮ ਘਟਾਉਂਦੇ ਹਨ:
Secret sharing ਉੱਚ-ਮੁੱਲ ਵਾਲੀਆਂ ਕੁੰਜੀਆਂ ਲਈ ਚਮਕਦਾਰ ਹੈ ਜਿੱਥੇ ਤੁਸੀਂ ਚਾਹੁੰਦੇ ਹੋ ਕਿ ਇੱਕ ਵੀ ਵਿਅਕਤੀ ਇਕੱਲਾ ਫੈਸਲਾ ਨਾ ਕਰੇ ਅਤੇ ਇੱਕ-ਅਦਮੀ ਨੁਕਸਾਨ ਨੁਕਸਾਨ ਨਾ ਬਣੇ:
ਜੇ ਤੁਹਾਡੀ ਮੁੱਖ ਸਮੱਸਿਆ "ਮੈਂ ਫਾਇਲਾਂ ਮਿਟਾ ਸਕਦਾ ਹਾਂ" ਜਾਂ "ਮੈਨੂੰ ਯੂਜ਼ਰ ਪਾਸਵਰਡ ਰੀਸੈਟ ਕਰਨੇ ਹਨ" ਹੈ, ਤਾਂ secret sharing ਆਮ ਤੌਰ 'ਤੇ ਬੇਕਾਰ ਹੈ। ਇਹ ਆਪਰੇਸ਼ਨਲ ਸੁਰੱਖਿਆ ਦੀ ਥਾਂ ਨਹੀਂ ਲੈਂਦਾ: ਜੇ ਹਮਲਾਵਰ ਕਈ share-holders ਨੂੰ ਠੱਗ ਸਕਦਾ ਹੈ ਜਾਂ ਉਹਨਾਂ ਦੇ ਡਿਵਾਈਸ ਕਮਪ੍ਰੋਮਾਈਜ਼ ਹੋ ਸਕਦੇ ਹਨ, ਤਾਂ threshold ਪੂਰਾ ਹੋ ਸਕਦਾ ਹੈ।
ਸਪੱਸ਼ਟ ਫੇਲ-ਮੋਡ ਉਪਲਬਧਤਾ ਹੈ: ਬਹੁਤ ਜ਼ਿਆਦਾ shares ਖੋ ਦਿਓ ਤਾਂ ਗੁਪਤ ਗੁੰਮ ਹੋ ਜਾਵੇਗਾ। ਨਾਜੁਕ ਖਤਰੇ ਮਨੁੱਖੀ ਹਨ:
ਪ੍ਰਕਿਰਿਆ ਦੀ ਦਸਤਾਵੇਜ਼ੀ ਕਰੋ, ਸਪਸ਼ਟ ਭੂਮਿਕਾਵਾਂ ਨਿਰਧਾਰਤ ਕਰੋ, ਅਤੇ—ਜਿਵੇਂ ਅੱਗ-ਅਭਿਆਸ—ਨੀਯਮਿਤ ਰਿਕਵਰੀ ਰਿਹਰਸਲ ਕਰਵਾਓ। ਇੱਕ provenance-ਹੀਨ secret-sharing ਯੋਜਨਾ ਉਮੀਦ ਤੋਂ ਜ਼ਿਆਦਾ ਇੱਕ ਆਸ-ਕਥਾ ਹੋਕੇ ਰਹਿ ਸਕਦੀ ਹੈ।
RSA ਅਤੇ Shamir ਦੀ Secret Sharing "ਅਲਗੋਰਿਦਮ" ਵਜੋਂ ਪਰਸਿੱਧ ਹਨ, ਪਰ ਉਨ੍ਹਾਂ ਦਾ ਅਸਲ ਪ੍ਰਭਾਵ ਉਸ ਵੇਲੇ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ ਜਦੋਂ ਉਹ ਉਹਨਾਂ ਸਿਸਟਮਾਂ ਵਿੱਚ ਲਗਾਏ ਜਾਂਦੇ ਹਨ ਜੋ ਲੋਕ ਅਤੇ ਸੰਸਥਾਵਾਂ ਸੰਚਾਲਿਤ ਕਰਦੀਆਂ ਹਨ: ਸਰਟੀਫਿਕੇਟ ਅਥਾਰਿਟੀਜ਼, ਮਨਜ਼ੂਰੀ ਵਰਕਫਲੋ, ਬੈਕਅੱਪ, ਅਤੇ ਘਟਨਾ ਰਿਕਵਰੀ।
RSA ਦਸਤਖਤ ਇਸ ਵਿਚਾਰ ਨੂੰ ਹਨੀ ਹੈ ਕਿ ਪਬਲਿਕ ਕੀ ਇੱਕ ਪਛਾਣ ਨੂੰ ਦਰਸਾ ਸਕਦੀ ਹੈ। ਅਮਲੀ ਰੂਪ ਵਿੱਚ, ਇਹ PKI ਬਣਦਾ ਹੈ: ਸਰਟੀਫਿਕੇਟ, ਸਰਟੀਫਿਕੇਟ ਚੇਨ, ਅਤੇ ਇਸ ਗੱਲ ਬਾਰੇ ਨੀਤੀਆਂ ਕਿ ਕੌਣ ਕੀ ਸਾਈਨ ਕਰ ਸਕਦਾ ਹੈ। ਇਕ ਕੰਪਨੀ ਸਿਰਫ਼ "RSA ਜਾਂ ਕਿਸੇ ਹੋਰ ਨੂੰ ਚੁਣਨਾ" ਨਹੀਂ—ਇਹ ਇਹ ਚੁਣਦੀ ਹੈ ਕਿ ਕੌਣ ਸਰਟੀਫਿਕੇਟ ਜਾਰੀ ਕਰੇਗਾ, ਕੁੰਜੀਆਂ ਕਿੰਨੀ ਵਾਰ ਰੋਟੇਟ ਹੋਣ, ਅਤੇ ਜਦੋਂ ਇੱਕ ਕੁੰਜੀ ਸੰਦੇਹਾਸਪਦ ਹੋ ਜਾਵੇ ਤਾਂ ਕੀ ਕਰਨਾ ਹੈ।
ਕੁੰਜੀ ਰੋਟੇਸ਼ਨ RSA ਦਾ ਅਪਰੇਸ਼ਨਲ ਭਰਾ ਹੈ: ਬਦਲਾਅ ਦੀ ਯੋਜਨਾ ਬਣਾਓ। ਛੋਟੇ-ਆਯੀਦੀ ਸਰਟੀਫਿਕੇਟ, ਨਿਯਮਤ ਬਦਲ, ਅਤੇ ਸਪਸ਼ਟ ਰਿਵੋਕੇਸ਼ਨ ਪ੍ਰਕਿਰਿਆਵਾਂ ਗਲਤੀਆਂ ਦੇ ਪ੍ਰਭਾਵ ਨੂੰ ਘਟਾਉਂਦੀਆਂ ਹਨ।
Secret sharing "ਇੱਕ ਕੁੰਜੀ, ਇੱਕ ਮਾਲਕ" ਨੂੰ ਇੱਕ ਭਰੋਸਾ ਮਾਡਲ ਵਿੱਚ ਬਦਲ ਦਿੰਦਾ ਹੈ। ਤੁਸੀਂ ਮੰਗ ਕਰ ਸਕਦੇ ਹੋ ਕਿ k-of-n ਲੋਕ (ਜਾਂ ਸਿਸਟਮ) recovery secret ਨੂੰ ਮੁੜ ਬਣਾਉਣ, ਮਹੱਤਵਪੂਰਨ ਕੰਫਿਗਰੇਸ਼ਨ ਬਦਲਸ਼ੁਦਾ ਕਰਨ, ਜਾਂ ਆਫਲਾਈਨ ਬੈਕਅੱਪ ਨੂੰ ਅਨਲੌਕ ਕਰਨ ਲਈ ਮਿਲਕੇ ਕੰਮ ਕਰਨ। ਇਸ ਨਾਲ ਸੁਰੱਖਿਅਤ ਰਿਕਵਰੀ ਯੋਗ ਹੋਦੀ ਹੈ: ਕੋਈ ਵੀ ਇਕ ਐਡਮਿਨ ਚੁਪਚਾਪ ਹਾਣੀ ਨਹੀਂ ਕਰ ਸਕਦਾ, ਅਤੇ ਕੋਈ ਵੀ ਇਕ ਗੁੰਮ ਪਾਸਵਰਡ ਹਮੇਸ਼ਾ ਸੰਕਟ ਨਹੀਂ ਬਣਾ ਸਕਦਾ।
ਚੰਗੀ ਸੁਰੱਖਿਆ ਪੁੱਛਦੀ ਹੈ: ਕੌਣ ਰਿਲੀਜ਼ ਸਾਈਨ ਕਰ ਸਕਦਾ ਹੈ, ਕੌਣ ਖਾਤੇ ਰਿਕਵਰ ਕਰ ਸਕਦਾ ਹੈ, ਅਤੇ ਕੌਣ ਨੀਤੀ ਬਦਲ ਸਕਦਾ ਹੈ? ਡਿਊਟੀਆਂ ਦਾ ਵੰਡਣਾ ਧੋਖਾ ਅਤੇ ਅਕਸਮਿਕ ਨੁਕਸਾਨ ਦੋਹਾਂ ਨੂੰ ਘਟਾਉਂਦਾ ਹੈ ਕਿਉਂਕਿ ਉੱਚ-ਪ੍ਰਭਾਵ ਵਾਲੀਆਂ ਕਾਰਵਾਈਆਂ ਲਈ ਸੁਤੰਤਰ ਸਹਿਮਤੀ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।
ਇੱਥੇ ਇਸ ਲਈ ਆਪਰੇਸ਼ਨਲ ਟੂਲਿੰਗ ਵੀ ਜ਼ਰੂਰੀ ਹੁੰਦੀ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਪਲੇਟਫਾਰਮ ਜਿਵੇਂ Koder.ai ਵਿੱਚ snapshots ਅਤੇ rollback ਵਰਗੀਆਂ ਫੀਚਰਾਂ ਸ਼ਾਮਿਲ ਹੋ ਸਕਦੀਆਂ ਹਨ, ਜੋ ਕਿ ਕੰਮ ਕਰਨ ਵਾਲੀ ਸਥਿਤੀ ਬਚਾਉਣ ਅਤੇ ਬਦਲਾਵ ਵਾਪਸ ਲਿਆਉਣ ਵਿੱਚ ਮਦਦ ਕਰਦੀਆਂ ਹਨ—ਪਰ ਇਹ ਸੁਰੱਖਿਆ ਸੁਰੱਖਿਆ ਸੰਭਾਲਾਂ ਤਦ ਹੀ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਹਨ ਜਦੋਂ ਉਹਨਾਂ ਨੂੰ ਨਿਯਮਤ ਸਾਈਨਿੰਗ, ਘੱਟ-ਅਧਿਕਾਰ ਪਹੁੰਚ, ਅਤੇ ਸਪਸ਼ਟ "ਕੌਣ ਕੀ ਮਨਜ਼ੂਰ ਕਰ ਸਕਦਾ ਹੈ" ਨੀਤੀਆਂ ਨਾਲ ਜੋੜਿਆ ਜਾਵੇ।
ਜਿਨ੍ਹਾਂ ਟੀਮਾਂ ਵੱਲੋਂ ਵੱਖ-ਵੱਖ ਸੁਰੱਖਿਆ ਪੱਧਰ ਦਿੱਤੇ ਜਾਂਦੇ ਹਨ—ਜਿਵੇਂ ਮੁੱਢਲਾ ਐਕਸੈਸ ਵਸਥਾ ਅਤੇ ਥ੍ਰੈਸ਼ਹੌਲਡ ਮਨਜ਼ੂਰੀਆਂ—ਕੀਮਤਾਂ ਨੂੰ ਸਪਸ਼ਟ ਕਰੋ (ਦੇਖੋ ਪ੍ਰਾਈਸਿੰਗ)।
ਇੱਕ ਕ੍ਰਿਪਟੋਗ੍ਰਾਫਿਕ ਅਲਗੋਰਿਦਮ ਕਾਗਜ਼ 'ਤੇ "ਸੁਰੱਖਿਅਤ" ਹੋ ਸਕਦਾ ਹੈ ਅਤੇ ਫਿਰ ਵੀ ਇਹਨਾਂ ਲੋਕਾਂ, ਡਿਵਾਈਸਾਂ, ਅਤੇ ਵਰਕਫਲੋਜ਼ ਦੇ ਸਾਹਮਣੇ ਫੇਲ ਹੋ ਸਕਦਾ ਹੈ। ਸੁਰੱਖਿਆ ਸਦਾ ਨਿਰੀਖਣਯੋਗ ਹੈ: ਇਹ ਉਸ ਦੇ ਉਪਰ ਨਿਰਭਰ ਕਰਦੀ ਹੈ ਕਿ ਕੌਣ ਤੁਹਾਨੂੰ ਹਮਲਾ ਕਰ ਸਕਦਾ ਹੈ, ਉਹ ਕੀ ਕਰ ਸਕਦੇ ਹਨ, ਤੁਸੀਂ ਕੀ ਸੁਰੱਖਿਆ ਕਰ ਰਹੇ ਹੋ, ਅਤੇ ਨੁਕਸਾਨ ਦੀ ਕੀ ਕੀਮਤ ਹੈ।
ਆਪਣੇ ਸੰਭਵ ਧਮਕੀ ਅਧਿਕਾਰੀਆਂ ਨੂੰ ਨਾਮ ਦੇ ਕੇ ਸ਼ੁਰੂ ਕਰੋ:
ਹਰ ਅਦਮੀ ਤੁਹਾਨੂੰ ਵੱਖਰੇ ਬਚਾਅਾਂ ਵੱਲ ਧਕਕਾ ਦੇਵੇਗਾ। ਜੇ ਤੁਸੀਂ ਮੁੱਖ ਤੌਰ 'ਤੇ ਬਾਹਰੀ ਹਮਲਾਵਰ ਤੋਂ ਡਰਦੇ ਹੋ, ਤੇ ਉਨ੍ਹਾਂ ਲਈ ਹੋਰਤਕਨੀ ਸ਼ਰਧਾ ਬਰਤੋਂ; ਜੇ ਇਨਸਾਈਡਰ ਵੱਡਾ ਖਤਰਾ ਹੈ, ਤਾ ਵੱਖਰੀ ਡਿਊਟੀ ਵੰਡ, ਆਡਿਟ ਟ੍ਰੇਲ, ਅਤੇ ਮਨਜ਼ੂਰੀ ਲੋੜੇ ਹੋਣ ਚਾਹੀਦੇ ਹਨ।
RSA ਅਤੇ secret sharing ਇਸ ਗੱਲ ਦੇ ਚੰਗੇ ਉਦਾਹਰਨ ਹਨ ਕਿ "ਵਧੀਆ ਗਣਿਤ" ਸਿਰਫ ਸ਼ੁਰੂਆਤ ਹੈ:
ਇੱਕ ਪ੍ਰਯੋਗਿਕ ਆਦਤ: ਆਪਣੇ ਧਮਕੀ ਮਾਡਲ ਨੂੰ ਛੋਟੀਆਂ ਲਾਈਨਾਂ 'ਚ ਦਸਤਾਵੇਜ਼ ਰੂਪ ਦੇਵੋ—ਤੁਸੀਂ ਕੀ ਬਚਾ ਰਹੇ ਹੋ, ਕਿਸ ਤੋਂ, ਅਤੇ ਕਿਹੜੀਆਂ ਅਸਫ਼ਲਤਾਵਾਂ ਬਰਦਾਸ਼ਤ ਕਰ ਸਕਦੇ ਹੋ। ਹਾਲਾਤ ਬਦਲਣ 'ਤੇ ਇਸ ਨੂੰ ਮੁੜ ਵੇਖੋ: ਨਵੇਂ ਟੀਮ ਮੈਂਬਰ, ਕਲਾਊਡ ਵਿੱਚ ਮੂਵ, ਇਕ मिलੀ-ਯੋਗਤਾ, ਜਾਂ ਨਵਾਂ ਨਿਯਮਾਂਤਰੀ ਲੋੜ।
ਜੇ ਤੁਸੀਂ ਗਲੋਬਲੀ ਤੌਰ 'ਤੇ ਡਿਪਲੋ ਯਕੀਨੀ ਕਰਦੇ ਹੋ, ਤਾਂ ਟਿਕਾਣਾ ਅਤੇ ਅਨੁਕੂਲਤਾ ਅਨੁਮਾਨ ਵੀ ਸ਼ਾਮਿਲ ਕਰੋ: ਕੁੰਜੀਆਂ ਕਿੱਥੇ ਰਹਿੰਦੀਆਂ ਹਨ, ਡਾਟਾ ਕਿੱਥੇ ਪ੍ਰੋਸੈਸ ਹੁੰਦਾ ਹੈ, ਅਤੇ ਕਿਹੜੇ ਬੋਰਡਰ-ਪਾਰ ਟੀਮਾਂ ਸਬੰਧੀ ਪਾਬੰਦੀਆਂ ਲਾਗੂ ਹੁੰਦੀਆਂ ਹਨ। (Koder.ai, ਉਦਾਹਰਨ ਵਜੋਂ, AWS 'ਤੇ ਗਲੋਬਲ ਤੌਰ 'ਤੇ ਚਲਦਾ ਹੈ ਅਤੇ ਵੱਖ-ਵੱਖ ਦੇਸ਼ਾਂ ਵਿੱਚ ਐਪ ਡਿਪਲੋ ਕਰ ਸਕਦਾ ਹੈ—ਪਰ ਮਾਡਲ ਨੂੰDEFINE ਕਰਨ ਅਤੇ ਸਹੀ ਤੌਰ 'ਤੇ ਕਨਫਿਗਰ ਕਰਨ ਦੀ ਜ਼ਿੰਮੇਵਾਰੀ ਫਿਰ ਭੀ ਟੀਮ ਦੀ ਹੁੰਦੀ ਹੈ।)
ਅਦੀ ਸ਼ਾਮੀਰ ਦਾ ਕੰਮ ਇਕ ਸਧਾਰਨ ਨਿਯਮ ਯਾਦ ਕਰਵਾਉਂਦਾ ਹੈ: ਸ਼ਾਨਦਾਰ ਕ੍ਰਿਪਟੋਗ੍ਰਾਫਿਕ ਵਿਚਾਰ ਸੁਰੱਖਿਆ ਸੰਭਵ ਬਣਾਉਂਦੇ ਹਨ, ਪਰ ਤੁਹਾਡੇ ਰੋਜ਼ਮਰ੍ਰਾ ਦੇ ਪ੍ਰਕਿਰਿਆਵਾਂ ਹੀ ਉਸਨੂੰ ਅਸਲੀ ਬਣਾਉਂਦੇ ਹਨ। RSA ਅਤੇ secret sharing ਸੋਹਣੇ ਨਿਰਮਾਣ-ਬਲਾਕ ਹਨ। ਪਰ ਵਾਸਤਵਿਕ ਰੱਖਿਆ ਇਸ ਗੱਲ 'ਤੇ ਨਿਰਭਰ ਕਰਦੀ ਹੈ ਕਿ ਕੁੰਜੀਆਂ ਕਿਵੇਂ ਬਣਾਈਆਂ, ਸਟੋਰ ਕੀਤੀਆਂ, ਵਰਤੀ ਗਈਆਂ, ਰੋਟੇਟ ਕੀਤੀਆਂ, ਬੈਕਅੱਪ ਕੀਤੀਆਂ, ਅਤੇ ਰਿਕਵਰ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ।
ਕ੍ਰਿਪਟੋਗ੍ਰਾਫੀ ਨੂੰ ਜਾਦੂ ਦੀ ਤਰ੍ਹਾਂ ਨਹੀਂ ਦੇਖੋ—ਇਹ ਇੰਜੀਨੀਅਰਿੰਗ ਹੈ। ਇੱਕ ਅਲਗੋਰਿਦਮ ਠੀਕ ਹੋ ਸਕਦਾ ਹੈ ਪਰ ਆਲੇ-ਦੁਆਲੇ ਦਾ ਸਿਸਟਮ ਕੰਮਜ਼ੋਰ ਹੋ ਸਕਦਾ ਹੈ—ਕਿਉਂਕਿ ਜਲਦੀ ਡਿਪਲੋ, ਅਸਪਸ਼ਟ ਮਾਲਕੀ, ਗੁੰਮ ਬੈਕਅੱਪ, ਜਾਂ "ਅਸਥਾਈ" ਛੋਟੇ ਸ਼ਾਰਟਕਟ ਲੰਬੀ ਅਰਸੇ ਵਿੱਚ ਪੱਕੇ ਹੋ ਸਕਦੇ ਹਨ।
ਜੇ ਤੁਸੀਂ ਕੁੰਜੀ ਪ੍ਰਬੰਧਨ ਅਤੇ ਆਪਰੇਸ਼ਨਲ ਸੁਰੱਖਿਆ 'ਤੇ ਹੋਰ ਪ੍ਰਯੋਗਿਕ ਗਾਈਡਾਂ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ blog 'ਚ ਸੰਬੰਧਤ ਪੋਸਟਾਂ ਵੇਖੋ।
A breakthrough adds a new capability—not just speed. In modern practice that usually means enabling confidentiality, integrity, and authenticity between parties who don’t share a secret in advance, at internet scale.
Symmetric crypto is fast, but it assumes both sides already share the same secret key. Public-key crypto introduces a public key you can share widely and a private key you keep secret, solving the key distribution problem for strangers and large systems.
RSA lets you publish a “lock” (public key) that anyone can use, while only you keep the “key” (private key) to decrypt or sign. It’s widely used for digital signatures, and historically for key transport/exchange in secure protocols.
It relies on modular arithmetic (“clock math”) and the assumption that factoring a very large number (the product of two large primes) is computationally infeasible at proper key sizes. It’s “assumed hard,” not mathematically proven impossible—so parameters and best practices matter.
Encryption answers: “Who can read this?” Signatures answer: “Who created/approved this, and was it changed?” In real systems you usually sign a hash of the data, and verifiers use the public key to check the signature.
Most real failures come from the surrounding system, such as:
Use vetted libraries and standard schemes (e.g., modern padding) instead of “raw RSA.”
Shamir’s Secret Sharing splits one secret into n shares so that any k shares can reconstruct it, while fewer than k reveal nothing useful. It’s a way to replace “one master key holder” with a controlled threshold of cooperating holders.
Use it for high-impact secrets where you want no single point of failure and no single person can act alone, such as:
Avoid it for everyday backups or low-value secrets where the operational overhead outweighs the benefit.
Choose k based on your real-world constraints:
Also ensure shares are separated across people, devices, and locations; otherwise you recreate the single point of failure you meant to remove.
Because security depends on threat models and operations, not just algorithms. Practical steps:
For more implementation guidance, see related posts at blog.