जावा क्रिप्टोग्राफी - त्वरित गाइड

क्रिप्टोग्राफी एक क्रिप्टोकरेंसी बनाने की कला और विज्ञान है जो सूचना सुरक्षा प्रदान करने में सक्षम है।

क्रिप्टोग्राफी डिजिटल डेटा की वास्तविक सुरक्षा से संबंधित है। यह गणितीय एल्गोरिदम पर आधारित तंत्र के डिजाइन को संदर्भित करता है जो मूलभूत सूचना सुरक्षा सेवाएं प्रदान करता है। आप क्रिप्टोग्राफी के बारे में सोच सकते हैं क्योंकि सुरक्षा अनुप्रयोगों में विभिन्न तकनीकों वाले एक बड़े टूलकिट की स्थापना।

Cryptanalysis क्या है?

सिफर टेक्स्ट को तोड़ने की कला और विज्ञान को क्रिप्टोनालिसिस के रूप में जाना जाता है।

क्रिप्टानालिसिस क्रिप्टोग्राफी की बहन शाखा है और वे दोनों सह-अस्तित्व में हैं। क्रिप्टोग्राफ़िक प्रक्रिया के परिणामस्वरूप संचरण या भंडारण के लिए सिफर पाठ होता है। इसमें उन्हें तोड़ने के इरादे से क्रिप्टोग्राफिक तंत्र का अध्ययन शामिल है। क्रिप्टानालिसिस का उपयोग नई क्रिप्टोग्राफिक तकनीकों के डिजाइन के दौरान उनकी सुरक्षा शक्तियों का परीक्षण करने के लिए भी किया जाता है।

क्रिप्टोग्राफी प्रिमिटिव

क्रिप्टोग्राफी प्रिमिटिव कुछ भी नहीं हैं, लेकिन क्रिप्टोग्राफी में उपकरण और तकनीकें जो वांछित सुरक्षा सेवाओं का एक सेट प्रदान करने के लिए चुनिंदा रूप से उपयोग की जा सकती हैं -

Encryption
हैश फ़ंक्शन
संदेश प्रमाणीकरण कोड (मैक)
डिजीटल हस्ताक्षर

जावा में क्रिप्टोग्राफी

जावा क्रिप्टोग्राफी आर्किटेक्चर (जेसीए) एपीआई की एक सेट है जो आधुनिक क्रिप्टोग्राफी की अवधारणाओं को लागू करने के लिए है जैसे डिजिटल हस्ताक्षर, संदेश डाइजेस्ट, प्रमाण पत्र, एन्क्रिप्शन, मुख्य पीढ़ी और प्रबंधन, और सुरक्षित यादृच्छिक संख्या पीढ़ी आदि।

जेसीए डेवलपर्स का उपयोग करना उनके अनुप्रयोगों को उन में सुरक्षा को एकीकृत करने का निर्माण कर सकता है।

जटिल सुरक्षा एल्गोरिदम के आधार पर अपने अनुप्रयोगों में सुरक्षा को एकीकृत करने के लिए आप आवश्यक सेवाओं के लिए जेसीए में संबंधित एपीआई के आसानी से कॉल कर सकते हैं।

हैश फ़ंक्शन बेहद उपयोगी हैं और लगभग सभी सूचना सुरक्षा अनुप्रयोगों में दिखाई देते हैं।

हैश फ़ंक्शन एक गणितीय फ़ंक्शन है जो संख्यात्मक इनपुट मान को दूसरे संपीड़ित संख्यात्मक मान में परिवर्तित करता है। हैश फ़ंक्शन का इनपुट मनमानी लंबाई का है, लेकिन आउटपुट हमेशा निश्चित लंबाई का होता है।

हैश फ़ंक्शन द्वारा लौटाए गए मानों को कहा जाता है message digest या केवल hash values। निम्न चित्र में हैश फ़ंक्शन का वर्णन किया गया है।

जावा नामक एक वर्ग प्रदान करता है MessageDigestजो पैकेज java.security के अंतर्गत आता है। यह वर्ग एल्गोरिदम जैसे SHA-1, SHA 256, MD5 एल्गोरिदम को एक मैसेज डाइजेस्ट में एक मनमाना लंबाई संदेश में परिवर्तित करने का समर्थन करता है।

किसी दिए गए संदेश को संदेश में बदलने के लिए, नीचे दिए गए चरणों का पालन करें -

चरण 1: एक MessageDigest ऑब्जेक्ट बनाएँ

MessageDigest वर्ग नाम की एक विधि प्रदान करता है getInstance()। यह विधि एक स्ट्रिंग चर का उपयोग करने के लिए एल्गोरिथ्म के नाम को निर्दिष्ट करती है और निर्दिष्ट एल्गोरिथ्म को लागू करने वाले एक मैसेजडिजेस्ट ऑब्जेक्ट को वापस करती है।

का उपयोग करके MessageDigest ऑब्जेक्ट बनाएँ getInstance() तरीका नीचे दिखाया गया है।

MessageDigest md = MessageDigest.getInstance("SHA-256");

चरण 2: डेटा को बनाए गए MessageDigest ऑब्जेक्ट को पास करें

मैसेज डाइजेस्ट ऑब्जेक्ट बनाने के बाद, आपको इसके लिए मैसेज / डेटा पास करना होगा। आप का उपयोग कर ऐसा कर सकते हैंupdate() की विधि MessageDigest वर्ग, यह विधि संदेश का प्रतिनिधित्व करने वाली बाइट सरणी को स्वीकार करती है और इसे ऊपर बनाई गई MessageDigest ऑब्जेक्ट में जोड़ / पास करती है।

md.update(msg.getBytes());

स्टेप 3: मैसेज डाइजेस्ट जनरेट करें

आप का उपयोग कर संदेश पचा उत्पन्न कर सकते हैं digest() मैसेजडिज मैसेजडिजेस्ट क्लास यह विधि करंट ऑब्जेक्ट पर हैश फंक्शन की गणना करती है और मैसेज को बाइट एरे के रूप में डाइजेस्ट करती है।

मैसेज डाइजेस्ट को डाइजेस्ट विधि का उपयोग करके जनरेट करें

byte[] digest = md.digest();

उदाहरण

निम्नलिखित एक उदाहरण है जो एक फ़ाइल से डेटा पढ़ता है और एक संदेश डाइजेस्ट उत्पन्न करता है और इसे प्रिंट करता है।

import java.security.MessageDigest;
import java.util.Scanner;

public class MessageDigestExample {
   public static void main(String args[]) throws Exception{
      //Reading data from user
      Scanner sc = new Scanner(System.in);
      System.out.println("Enter the message");
      String message = sc.nextLine();
	  
      //Creating the MessageDigest object  
      MessageDigest md = MessageDigest.getInstance("SHA-256");

      //Passing data to the created MessageDigest Object
      md.update(message.getBytes());
      
      //Compute the message digest
      byte[] digest = md.digest();      
      System.out.println(digest);  
     
      //Converting the byte array in to HexString format
      StringBuffer hexString = new StringBuffer();
      
      for (int i = 0;i<digest.length;i++) {
         hexString.append(Integer.toHexString(0xFF & digest[i]));
      }
      System.out.println("Hex format : " + hexString.toString());     
   }
}

उत्पादन

उपरोक्त कार्यक्रम निम्नलिखित आउटपुट उत्पन्न करता है -

Enter the message
Hello how are you
[B@55f96302
Hex format: 2953d33828c395aebe8225236ba4e23fa75e6f13bd881b9056a3295cbd64d3

मैक (Message Authentication Code) एल्गोरिथ्म संदेश प्रमाणीकरण प्रदान करने के लिए एक सममित कुंजी क्रिप्टोग्राफ़िक तकनीक है। मैक प्रक्रिया की स्थापना के लिए, प्रेषक और रिसीवर एक सममित कुंजी के साझा करते हैं।

अनिवार्य रूप से, एक मैक एक एन्क्रिप्टेड चेकसम है जो अंतर्निहित संदेश पर उत्पन्न होता है जो संदेश प्रमाणीकरण सुनिश्चित करने के लिए एक संदेश के साथ भेजा जाता है।

प्रमाणीकरण के लिए मैक का उपयोग करने की प्रक्रिया को निम्न चित्रण में दर्शाया गया है -

जावा में Mac की कक्षा javax.cryptoपैकेज संदेश प्रमाणीकरण कोड की कार्यक्षमता प्रदान करता है। इस वर्ग का उपयोग करके संदेश प्रमाणीकरण कोड बनाने के लिए नीचे दिए गए चरणों का पालन करें।

चरण 1: एक KeyGenerator ऑब्जेक्ट बनाएँ

KeyGenerator वर्ग प्रदान करता है getInstance() विधि जो एक स्ट्रिंग चर को स्वीकार करती है जो आवश्यक कुंजी-जनरेटिंग एल्गोरिथ्म का प्रतिनिधित्व करती है और वापस आती है KeyGenerator वह वस्तु जो गुप्त कुंजी उत्पन्न करती है।

सृजन करना KeyGenerator का उपयोग कर वस्तु getInstance() तरीका नीचे दिखाया गया है।

//Creating a KeyGenerator object
KeyGenerator keyGen = KeyGenerator.getInstance("DES");

चरण 2: सिक्योर रैंडम ऑब्जेक्ट बनाएं

SecureRandom की कक्षा java.Securityपैकेज एक मजबूत यादृच्छिक संख्या जनरेटर प्रदान करता है जिसका उपयोग जावा में यादृच्छिक संख्या उत्पन्न करने के लिए किया जाता है। नीचे दिखाए अनुसार इस वर्ग को त्वरित करें।

//Creating a SecureRandom object
SecureRandom secRandom = new SecureRandom();

चरण 3: प्रारंभ करें KeyGenerator

KeyGenerator क्लास नाम की एक विधि प्रदान करता है init() यह तरीका स्वीकार करता है SecureRandom ऑब्जेक्ट और वर्तमान को इनिशियलाइज़ करता है KeyGenerator।

इस विधि का उपयोग करके पिछले चरण में बनाए गए KeyGenerator ऑब्जेक्ट को प्रारंभ करें।

//Initializing the KeyGenerator
keyGen.init(secRandom);

चरण 4: कुंजी उत्पन्न करें

का उपयोग कर उत्पन्न करें generateKey() की विधि KeyGenerator नीचे दिखाया गया है।

//Creating/Generating a key
Key key = keyGen.generateKey();

चरण 5: मैक ऑब्जेक्ट को इनिशियलाइज़ करें

init() मैक क्लास की विधि एक मुख्य ऑब्जेक्ट को स्वीकार करती है और दिए गए कुंजी का उपयोग करके वर्तमान मैक ऑब्जेक्ट को इनिशियलाइज़ करती है।

//Initializing the Mac object
mac.init(key);

चरण 6: मैक ऑपरेशन समाप्त करें

doFinal()मैक ऑपरेशन को समाप्त करने के लिए मैक क्लास की विधि का उपयोग किया जाता है। इस विधि को बाइट सरणी के रूप में आवश्यक डेटा पास करें और नीचे दिखाए अनुसार ऑपरेशन को खत्म करें।

//Computing the Mac
String msg = new String("Hi how are you");
byte[] bytes = msg.getBytes();
byte[] macResult = mac.doFinal(bytes);

उदाहरण

निम्न उदाहरण जेसीए का उपयोग करते हुए संदेश प्रमाणीकरण कोड (मैक) की पीढ़ी को प्रदर्शित करता है। यहां, हम एक सरल संदेश "हाय तुम कैसे हो" लेते हैं और, उस संदेश के लिए एक मैक उत्पन्न करते हैं।

import java.security.Key;
import java.security.SecureRandom;

import javax.crypto.KeyGenerator;
import javax.crypto.Mac;

public class MacSample {
   public static void main(String args[]) throws Exception{
      //Creating a KeyGenerator object
      KeyGenerator keyGen = KeyGenerator.getInstance("DES");

      //Creating a SecureRandom object
      SecureRandom secRandom = new SecureRandom();

      //Initializing the KeyGenerator
      keyGen.init(secRandom);

      //Creating/Generating a key
      Key key = keyGen.generateKey();	 

      //Creating a Mac object
      Mac mac = Mac.getInstance("HmacSHA256");

      //Initializing the Mac object
      mac.init(key);

      //Computing the Mac
      String msg = new String("Hi how are you");
      byte[] bytes = msg.getBytes();      
      byte[] macResult = mac.doFinal(bytes);

      System.out.println("Mac result:");
      System.out.println(new String(macResult));     
   }
}

उत्पादन

उपरोक्त कार्यक्रम निम्न आउटपुट उत्पन्न करेगा -

Mac result:
HÖ„^ÇƒÎ_Utbh…?š_üzØSSÜh_ž_œa0ŽV?

एक क्रिप्टोकरेंसी क्रिप्टोग्राफ़िक तकनीकों और उनके साथ बुनियादी ढांचे का कार्यान्वयन है जो सूचना सुरक्षा सेवाएं प्रदान करता है। एक क्रिप्टोकरेंसी को एक के रूप में भी संदर्भित किया जाता हैcipher system।

एक बुनियादी क्रिप्टोकरेंसी के विभिन्न घटक हैं Plaintext, Encryption Algorithm, Ciphertext, Decryption Algorithm, एन्क्रिप्शन कुंजी और, डिक्रिप्शन कुंजी।

कहाँ पे,

Encryption Keyएक ऐसा मूल्य है जो प्रेषक को ज्ञात होता है। भेजने वाले पाठ की गणना करने के लिए प्रेषक एन्क्रिप्शन एल्गोरिथ्म में प्लेनटेक्स्ट के साथ एन्क्रिप्शन कुंजी को इनपुट करता है।
Decryption Keyएक ऐसा मूल्य है जो रिसीवर को ज्ञात होता है। डिक्रिप्शन कुंजी एन्क्रिप्शन कुंजी से संबंधित है, लेकिन हमेशा इसके समान नहीं है। रिसीवर सांद्रता पाठ के साथ डिक्रिप्शन एल्गोरिथ्म में डिक्रिप्शन कुंजी का उपयोग करता है ताकि प्लेनटेक्स्ट की गणना की जा सके।

मूलभूत रूप से एन्क्रिप्शन-डिक्रिप्शन एल्गोरिदम के प्रकार के आधार पर दो प्रकार की कुंजी / क्रिप्टोकरंसी हैं।

सममित कुंजी एन्क्रिप्शन

एन्क्रिप्शन प्रक्रिया जहां same keys are used for encrypting and decrypting जानकारी को सममित कुंजी एन्क्रिप्शन के रूप में जाना जाता है।

सममित क्रिप्टो सिस्टम के अध्ययन को संदर्भित किया जाता है symmetric cryptography। सममित क्रिप्टोसिस्टम को भी कभी-कभी कहा जाता हैsecret key cryptosystems।

सममित कुंजी एन्क्रिप्शन के कुछ सामान्य उदाहरण निम्नलिखित हैं -

डिजिटल एन्क्रिप्शन स्टैंडर्ड (DES)
ट्रिपल-डेस (3DES)
IDEA
BLOWFISH

असममित कुंजी एन्क्रिप्शन

एन्क्रिप्शन प्रक्रिया जहां different keys are used for encrypting and decrypting the informationअसममित कुंजी एन्क्रिप्शन के रूप में जाना जाता है। यद्यपि कुंजियाँ भिन्न हैं, वे गणितीय रूप से संबंधित हैं और इसलिए, सिफर पाठ को डिक्रिप्ट करके प्लेनटेक्स्ट को पुनः प्राप्त करना संभव है।

उपयोग किए गए / उत्पन्न किए गए कुंजी और प्रमाण पत्र एक डेटा बेस में संग्रहीत किए जाते हैं जिन्हें कीस्टोर कहा जाता है। डिफ़ॉल्ट रूप से यह डेटाबेस नाम की एक फ़ाइल में संग्रहीत किया जाता है.keystore।

आप इस डेटाबेस की सामग्री का उपयोग कर सकते हैं KeyStore की कक्षा java.securityपैकेज। यह तीन अलग-अलग प्रविष्टियों का प्रबंधन करता है, PrivateKeyEntry, SecretKeyEntry, TrustedCertificateEntry।

PrivateKeyEntry
SecretKeyEntry
TrustedCertificateEntry

कीस्टोर में एक कुंजी जमा करना

इस अनुभाग में, हम सीखेंगे कि कीस्टोर में एक कुंजी कैसे संग्रहीत करें। कीस्टोर में एक कुंजी स्टोर करने के लिए, नीचे दिए गए चरणों का पालन करें।

चरण 1: एक KeyStore ऑब्जेक्ट बनाएँ

getInstance() की विधि KeyStore की कक्षा java.security पैकेज कीस्टोर के प्रकार का प्रतिनिधित्व करने वाला एक स्ट्रिंग मान स्वीकार करता है और एक KeyStore वस्तु देता है।

का उपयोग कर KeyStore वर्ग का एक ऑब्जेक्ट बनाएँ getInstance() तरीका नीचे दिखाया गया है।

//Creating the KeyStore object
KeyStore keyStore = KeyStore.getInstance("JCEKS");

चरण 2: KeyStore ऑब्जेक्ट को लोड करें

load() KeyStore क्लास का तरीका एक FileInputStream ऑब्जेक्ट को स्वीकार करता है जो कीस्टोर फाइल का प्रतिनिधित्व करता है और एक स्ट्रिंग पैरामीटर KeyStore के पासवर्ड को निर्दिष्ट करता है।

सामान्य तौर पर, KeyStore नाम की फ़ाइल में संग्रहीत किया जाता है cacertsस्थान में C:/Program Files/Java/jre1.8.0_101/lib/security/ और इसका डिफ़ॉल्ट पासवर्ड है changeit, का उपयोग कर इसे लोड करें load() तरीका नीचे दिखाया गया है।

//Loading the KeyStore object
char[] password = "changeit".toCharArray();
String path = "C:/Program Files/Java/jre1.8.0_101/lib/security/cacerts";
java.io.FileInputStream fis = new FileInputStream(path);
keyStore.load(fis, password);

चरण 3: KeyStore.ProtectionParameter ऑब्जेक्ट बनाएँ

नीचे दिखाए अनुसार KeyStore.ProtectionParameter को झटपट बंद करें।

//Creating the KeyStore.ProtectionParameter object
KeyStore.ProtectionParameter protectionParam = new KeyStore.PasswordProtection(password);

चरण 4: एक गुप्त वस्तु बनाएँ

बनाएँ SecretKey (इंटरफ़ेस) ऑब्जेक्ट को अपनी सब क्लास को इंस्टेंट करके SecretKeySpec। तत्काल करते समय आपको पासवर्ड और एल्गोरिथ्म को इसके निर्माता को पैरामीटर के रूप में पास करना होगा जैसा कि नीचे दिखाया गया है।

//Creating SecretKey object
SecretKey mySecretKey = new SecretKeySpec(new String(keyPassword).getBytes(), "DSA");

चरण 5: एक सीक्रेटकेन्ट्री ऑब्जेक्ट बनाएं

का एक ऑब्जेक्ट बनाएँ SecretKeyEntry पास करके कक्षा SecretKey उपरोक्त चरण में बनाई गई वस्तु जैसा कि नीचे दिखाया गया है।

//Creating SecretKeyEntry object
KeyStore.SecretKeyEntry secretKeyEntry = new KeyStore.SecretKeyEntry(mySecretKey);

चरण 6: KeyStore में एक प्रविष्टि सेट करें

setEntry() की विधि KeyStore वर्ग एक स्ट्रिंग पैरामीटर को स्वीकार करता है जो किस्टोर एंट्री उर्फ, ए का प्रतिनिधित्व करता है SecretKeyEntry ऑब्जेक्ट, एक प्रोटेक्शनपार्ट ऑब्जेक्ट और, दिए गए उपनाम के तहत प्रविष्टि को संग्रहीत करता है।

का उपयोग कर कीस्टोर में प्रवेश सेट करें setEntry() तरीका नीचे दिखाया गया है।

//Set the entry to the keystore
keyStore.setEntry("secretKeyAlias", secretKeyEntry, protectionParam);

Example

निम्न उदाहरण "कैसर्ट" फ़ाइल (विंडोज़ 10 ऑपरेटिंग सिस्टम) में मौजूद कीस्टोर में कुंजियों को संग्रहीत करता है।

import java.io.FileInputStream;
import java.security.KeyStore;

import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;

public class StoringIntoKeyStore{
   public static void main(String args[]) throws Exception {
      //Creating the KeyStore object
      KeyStore keyStore = KeyStore.getInstance("JCEKS");

      //Loading the KeyStore object
      char[] password = "changeit".toCharArray();
      String path = "C:/Program Files/Java/jre1.8.0_101/lib/security/cacerts";
      java.io.FileInputStream fis = new FileInputStream(path);
      keyStore.load(fis, password);
      
      //Creating the KeyStore.ProtectionParameter object
      KeyStore.ProtectionParameter protectionParam = new KeyStore.PasswordProtection(password);

      //Creating SecretKey object
      SecretKey mySecretKey = new SecretKeySpec("myPassword".getBytes(), "DSA");
      
      //Creating SecretKeyEntry object
      KeyStore.SecretKeyEntry secretKeyEntry = new KeyStore.SecretKeyEntry(mySecretKey);
      keyStore.setEntry("secretKeyAlias", secretKeyEntry, protectionParam);

      //Storing the KeyStore object
      java.io.FileOutputStream fos = null;
      fos = new java.io.FileOutputStream("newKeyStoreName");
      keyStore.store(fos, password);
      System.out.println("data stored");
   }
}

Output

उपरोक्त कार्यक्रम निम्नलिखित आउटपुट उत्पन्न करता है -

System.out.println("data stored");

इस अध्याय में, हम सीखेंगे कि जावा क्रिप्टोग्राफी का उपयोग करके कीस्टोर से एक कुंजी कैसे प्राप्त करें।

कीस्टोर से एक कुंजी प्राप्त करने के लिए, नीचे दिए गए चरणों का पालन करें।

चरण 1: एक KeyStore ऑब्जेक्ट बनाएँ

नीचे दिखाए गए अनुसार इस विधि का उपयोग करके KeyStore वर्ग का एक ऑब्जेक्ट बनाएं।

//Creating the KeyStore object
KeyStore keyStore = KeyStore.getInstance("JCEKS");

चरण 2: KeyStore ऑब्जेक्ट को लोड करें

load() KeyStore क्लास का तरीका स्वीकार करता है a FileInputStream कीस्टोर फाइल का प्रतिनिधित्व करने वाली वस्तु और एक स्ट्रिंग पैरामीटर KeyStore के पासवर्ड को निर्दिष्ट करता है।

//Loading the KeyStore object
char[] password = "changeit".toCharArray();
String path = "C:/Program Files/Java/jre1.8.0_101/lib/security/cacerts";
java.io.FileInputStream fis = new FileInputStream(path);
keyStore.load(fis, password);

चरण 3: KeyStore.ProtectionParameter ऑब्जेक्ट बनाएँ

नीचे दिखाए अनुसार KeyStore.ProtectionParameter को झटपट बंद करें।

//Creating the KeyStore.ProtectionParameter object
KeyStore.ProtectionParameter protectionParam = new KeyStore.PasswordProtection(password);

चरण 4: एक गुप्त वस्तु बनाएँ

//Creating SecretKey object
SecretKey mySecretKey = new SecretKeySpec(new String(keyPassword).getBytes(), "DSA");

चरण 5: एक सीक्रेटकेन्ट्री ऑब्जेक्ट बनाएं

//Creating SecretKeyEntry object
KeyStore.SecretKeyEntry secretKeyEntry = new KeyStore.SecretKeyEntry(mySecretKey);

चरण 6: KeyStore के लिए एक प्रविष्टि सेट करें

का उपयोग कर कीस्टोर में प्रवेश सेट करें setEntry() तरीका नीचे दिखाया गया है।

//Set the entry to the keystore
keyStore.setEntry("secretKeyAlias", secretKeyEntry, protectionParam);

चरण 7: KeyStore.SecretKeyEntry ऑब्जेक्ट बनाएँ

getEntry() KeyStore वर्ग की विधि एक उपनाम (स्ट्रिंग पैरामीटर) और मानदंड के रूप में ProtectionParameter वर्ग का एक ऑब्जेक्ट स्वीकार करती है KeyStoreEntry ऑब्जेक्ट तब आप इसे इसमें डाल सकते हैं KeyStore.SecretKeyEntry वस्तु।

आवश्यक कुंजी के लिए उपनाम पारित करके और पिछले चरणों में बनाए गए सुरक्षा पैरामीटर ऑब्जेक्ट के लिए KeyStore.SecretKeyEntry वर्ग की एक वस्तु बनाएं। getEntry() तरीका नीचे दिखाया गया है।

//Creating the KeyStore.SecretKeyEntry object
KeyStore.SecretKeyEntry secretKeyEnt = (KeyStore.SecretKeyEntry)keyStore.getEntry("secretKeyAlias", protectionParam);

चरण 8: पुनःप्राप्त प्रविष्टि की मुख्य वस्तु बनाएं

getSecretKey() की विधि SecretKeyEntryक्लास एक सीक्रेट चीज़ लौटाता है। इस विधि का उपयोग करके नीचे दिखाए गए अनुसार एक गुप्त वस्तु बनाएं।

//Creating SecretKey object
SecretKey mysecretKey = secretKeyEnt.getSecretKey();      
System.out.println(mysecretKey);

उदाहरण

निम्नलिखित उदाहरण से पता चलता है कि कुंजी स्टोर से कुंजियों को कैसे पुनः प्राप्त करें। यहां, हम एक कीस्टोर में एक कुंजी स्टोर करते हैं, जो "कैसैर्ट्स" फ़ाइल (विंडोज़ 10 ऑपरेटिंग सिस्टम) में है, इसे पुनः प्राप्त करते हैं, और इसके कुछ गुणों को प्रदर्शित करते हैं जैसे कि एल्गोरिथ्म कुंजी और उत्पन्न करने के लिए उपयोग किया जाता है, का प्रारूप पुनः प्राप्त की।

import java.io.FileInputStream;
import java.security.KeyStore;
import java.security.KeyStore.ProtectionParameter;
import java.security.KeyStore.SecretKeyEntry;

import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;

public class RetrievingFromKeyStore{
   public static void main(String args[]) throws Exception{
      //Creating the KeyStore object
      KeyStore keyStore = KeyStore.getInstance("JCEKS");

      //Loading the the KeyStore object
      char[] password = "changeit".toCharArray();
      java.io.FileInputStream fis = new FileInputStream(
         "C:/Program Files/Java/jre1.8.0_101/lib/security/cacerts");
      
      keyStore.load(fis, password);
      
      //Creating the KeyStore.ProtectionParameter object
      ProtectionParameter protectionParam = new KeyStore.PasswordProtection(password);

      //Creating SecretKey object
      SecretKey mySecretKey = new SecretKeySpec("myPassword".getBytes(), "DSA");
      
      //Creating SecretKeyEntry object
      SecretKeyEntry secretKeyEntry = new SecretKeyEntry(mySecretKey);
      keyStore.setEntry("secretKeyAlias", secretKeyEntry, protectionParam);

      //Storing the KeyStore object
      java.io.FileOutputStream fos = null;
      fos = new java.io.FileOutputStream("newKeyStoreName");
      keyStore.store(fos, password);
      
      //Creating the KeyStore.SecretKeyEntry object
      SecretKeyEntry secretKeyEnt = (SecretKeyEntry)keyStore.getEntry("secretKeyAlias", protectionParam);

      //Creating SecretKey object
      SecretKey mysecretKey = secretKeyEnt.getSecretKey();      
      System.out.println("Algorithm used to generate key : "+mysecretKey.getAlgorithm());   
      System.out.println("Format used for the key: "+mysecretKey.getFormat());
   }
}

उत्पादन

उपरोक्त कार्यक्रम निम्नलिखित आउटपुट उत्पन्न करता है -

Algorithm used to generate key: DSA
Format of the key: RAW

जावा प्रदान करता है KeyGenerator इस वर्ग का उपयोग गुप्त कुंजियों को उत्पन्न करने के लिए किया जाता है और इस वर्ग की वस्तुएँ पुन: प्रयोज्य होती हैं।

KeyGenerator क्लास का उपयोग करके चाबियाँ बनाने के लिए नीचे दिए गए चरणों का पालन करें।

चरण 1: एक KeyGenerator ऑब्जेक्ट बनाएँ

KeyGenerator वर्ग प्रदान करता है getInstance() वह विधि जो आवश्यक कुंजी-जनरेटिंग एल्गोरिथ्म का प्रतिनिधित्व करने वाले स्ट्रिंग चर को स्वीकार करती है और एक KeyGenerator ऑब्जेक्ट देता है जो गुप्त कुंजी उत्पन्न करता है।

सृजन करना KeyGenerator का उपयोग कर वस्तु getInstance() तरीका नीचे दिखाया गया है।

//Creating a KeyGenerator object
KeyGenerator keyGen = KeyGenerator.getInstance("DES");

चरण 2: सिक्योर रैंडम ऑब्जेक्ट बनाएं

//Creating a SecureRandom object
SecureRandom secRandom = new SecureRandom();

चरण 3: प्रारंभ करें KeyGenerator

KeyGenerator क्लास नाम की एक विधि प्रदान करता है init() यह विधि सिक्योर रैंडम ऑब्जेक्ट को स्वीकार करती है और करंट को इनिशियलाइज़ करती है KeyGenerator।

KeyGenerator ऑब्जेक्ट का उपयोग करके पिछले चरण में बनाया गया है init() तरीका।

//Initializing the KeyGenerator
keyGen.init(secRandom);

उदाहरण

निम्न उदाहरण KeyGenerator वर्ग के उपयोग से गुप्त कुंजी की प्रमुख पीढ़ी को प्रदर्शित करता है javax.crypto पैकेज।

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;

import java.security.Key;
import java.security.SecureRandom;

public class KeyGeneratorExample {
   public static void main(String args[]) throws Exception{
      //Creating a KeyGenerator object
      KeyGenerator keyGen = KeyGenerator.getInstance("DES");
      
      //Creating a SecureRandom object
      SecureRandom secRandom = new SecureRandom();
      
      //Initializing the KeyGenerator
      keyGen.init(secRandom);
      
      //Creating/Generating a key
      Key key = keyGen.generateKey();
      
      System.out.println(key);      
      Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding");      
      cipher.init(cipher.ENCRYPT_MODE, key);      

      String msg = new String("Hi how are you");
      byte[] bytes = cipher.doFinal(msg.getBytes());      
      System.out.println(bytes);      
   }
}

उत्पादन

उपरोक्त कार्यक्रम निम्नलिखित आउटपुट उत्पन्न करता है -

com.sun.crypto.provider.DESKey@18629
[B@2ac1fdc4

जावा प्रदान करता है KeyPairGeneratorकक्षा। इस वर्ग का उपयोग सार्वजनिक और निजी कुंजी के जोड़े बनाने के लिए किया जाता है। का उपयोग कर चाबियाँ उत्पन्न करने के लिएKeyPairGenerator कक्षा, नीचे दिए गए चरणों का पालन करें।

चरण 1: एक KeyPairGenerator ऑब्जेक्ट बनाएँ

KeyPairGenerator वर्ग प्रदान करता है getInstance() वह विधि जो आवश्यक कुंजी-जनरेटिंग एल्गोरिथ्म का प्रतिनिधित्व करने वाले स्ट्रिंग चर को स्वीकार करती है और KeyPairGenerator ऑब्जेक्ट देता है जो कुंजी उत्पन्न करता है।

सृजन करना KeyPairGenerator का उपयोग कर वस्तु getInstance() तरीका नीचे दिखाया गया है।

//Creating KeyPair generator object
KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("DSA");

चरण 2: KeyPairGenerator ऑब्जेक्ट को प्रारंभ करें

KeyPairGenerator क्लास नाम की एक विधि प्रदान करता है initialize()इस विधि का उपयोग प्रमुख जोड़ी जनरेटर को आरंभ करने के लिए किया जाता है। यह विधि मुख्य आकार का प्रतिनिधित्व करने वाले पूर्णांक मान को स्वीकार करती है।

नीचे दिखाए गए अनुसार इस विधि का उपयोग करके पिछले चरण में बनाए गए KeyPairGenerator ऑब्जेक्ट को आरम्भ करें।

//Initializing the KeyPairGenerator
keyPairGen.initialize(2048);

चरण 3: KeyPairGenerator उत्पन्न करें

आप उत्पन्न कर सकते हैं KeyPair का उपयोग करते हुए generateKeyPair() की विधि KeyPairGeneratorकक्षा। नीचे दिखाए गए अनुसार इस पद्धति का उपयोग करके मुख्य जोड़ी बनाएं।

//Generate the pair of keys
KeyPair pair = keyPairGen.generateKeyPair();

चरण 4: निजी कुंजी / सार्वजनिक कुंजी प्राप्त करें

का उपयोग कर उत्पन्न KeyPair ऑब्जेक्ट से आप निजी कुंजी प्राप्त कर सकते हैं getPrivate() तरीका नीचे दिखाया गया है।

//Getting the private key from the key pair
PrivateKey privKey = pair.getPrivate();

आप जनरेट किए गए KeyPair ऑब्जेक्ट से सार्वजनिक कुंजी प्राप्त कर सकते हैं getPublic() तरीका नीचे दिखाया गया है।

//Getting the public key from the key pair
PublicKey publicKey = pair.getPublic();

उदाहरण

निम्न उदाहरण KeyPairGenerator वर्ग का उपयोग करके गुप्त कुंजी की मुख्य पीढ़ी को प्रदर्शित करता है javax.crypto पैकेज।

import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;

public class KeyPairGenertor {
   public static void main(String args[]) throws Exception{
      //Creating KeyPair generator object
      KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("DSA");
      
      //Initializing the KeyPairGenerator
      keyPairGen.initialize(2048);
      
      //Generating the pair of keys
      KeyPair pair = keyPairGen.generateKeyPair();
      
      //Getting the private key from the key pair
      PrivateKey privKey = pair.getPrivate();   
      
      //Getting the public key from the key pair
      PublicKey publicKey = pair.getPublic(); 
      System.out.println("Keys generated");
   }
}

उत्पादन

उपरोक्त कार्यक्रम निम्नलिखित आउटपुट उत्पन्न करता है -

Keys generated

डिजिटल हस्ताक्षर हमें लेखक, दिनांक और हस्ताक्षर के समय को सत्यापित करने, संदेश सामग्री को प्रमाणित करने की अनुमति देते हैं। इसमें अतिरिक्त क्षमताओं के लिए प्रमाणीकरण समारोह भी शामिल है।

डिजिटल हस्ताक्षर के लाभ

इस खंड में, हम उन विभिन्न कारणों के बारे में जानेंगे जो डिजिटल हस्ताक्षर के उपयोग के लिए कहते हैं। संचार के लिए डिजिटल हस्ताक्षर लागू करने के कई कारण हैं -

प्रमाणीकरण

डिजिटल हस्ताक्षर संदेशों के स्रोतों को प्रमाणित करने में मदद करते हैं। उदाहरण के लिए, यदि किसी बैंक का शाखा कार्यालय केंद्रीय कार्यालय को एक संदेश भेजता है, तो एक खाते के शेष में परिवर्तन के लिए अनुरोध करता है। यदि केंद्रीय कार्यालय अधिकृत स्रोत से उस संदेश को प्रमाणित नहीं कर सकता है, तो ऐसे अनुरोध का अभिनय एक गंभीर गलती हो सकती है।

अखंडता

एक बार संदेश पर हस्ताक्षर करने के बाद, संदेश में कोई भी परिवर्तन हस्ताक्षर को अमान्य कर देगा।

गैर परित्याग

इस संपत्ति के द्वारा, किसी भी संस्था ने कुछ जानकारी पर हस्ताक्षर किए हैं जो बाद में उस पर हस्ताक्षर करने से इनकार नहीं कर सकते हैं।

डिजिटल हस्ताक्षर बनाना

आइए अब सीखते हैं कि डिजिटल हस्ताक्षर कैसे बनाएं। आप नीचे दिए गए चरणों का पालन करके जावा का उपयोग करके डिजिटल हस्ताक्षर बना सकते हैं।

चरण 1: एक KeyPairGenerator ऑब्जेक्ट बनाएँ

सृजन करना KeyPairGenerator का उपयोग कर वस्तु getInstance() तरीका नीचे दिखाया गया है।

//Creating KeyPair generator object
KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("DSA");

चरण 2: KeyPairGenerator ऑब्जेक्ट को प्रारंभ करें

KeyPairGenerator ऑब्जेक्ट को चरण का उपयोग करके पिछले चरण में बनाया गया प्रारंभ करें initialize() तरीका नीचे दिखाया गया है।

//Initializing the KeyPairGenerator
keyPairGen.initialize(2048);

चरण 3: KeyPairGenerator उत्पन्न करें

आप उत्पन्न कर सकते हैं KeyPair का उपयोग करते हुए generateKeyPair()तरीका। कुंजी जोड़ी का उपयोग करके उत्पन्न करेंgenerateKeyPair() तरीका नीचे दिखाया गया है।

//Generate the pair of keys
KeyPair pair = keyPairGen.generateKeyPair();

चरण 4: जोड़ी से निजी कुंजी प्राप्त करें

का उपयोग कर उत्पन्न KeyPair ऑब्जेक्ट से आप निजी कुंजी प्राप्त कर सकते हैं getPrivate() तरीका।

का उपयोग कर निजी कुंजी प्राप्त करें getPrivate() तरीका नीचे दिखाया गया है।

//Getting the private key from the key pair
PrivateKey privKey = pair.getPrivate();

चरण 5: एक हस्ताक्षर वस्तु बनाएं

getInstance() की विधि Signature वर्ग आवश्यक हस्ताक्षर एल्गोरिथ्म का प्रतिनिधित्व करने वाले एक स्ट्रिंग पैरामीटर को स्वीकार करता है और संबंधित हस्ताक्षर वस्तु लौटाता है।

का उपयोग करके हस्ताक्षर वर्ग की एक वस्तु बनाएँ getInstance() तरीका।

//Creating a Signature object
Signature sign = Signature.getInstance("SHA256withDSA");

चरण 6: हस्ताक्षर वस्तु को आरम्भिक करें

initSign() हस्ताक्षर वर्ग की विधि एक स्वीकार करता है PrivateKey ऑब्जेक्ट और वर्तमान हस्ताक्षर ऑब्जेक्ट को इनिशियलाइज़ करता है।

का उपयोग करके पिछले चरण में बनाई गई हस्ताक्षर वस्तु को प्रारंभ करें initSign() तरीका नीचे दिखाया गया है।

//Initialize the signature
sign.initSign(privKey);

चरण 7: हस्ताक्षर ऑब्जेक्ट में डेटा जोड़ें

update() हस्ताक्षर वर्ग की विधि डेटा को दर्शाती या सत्यापित की जाने वाली बाइट सरणी को स्वीकार करती है और दिए गए डेटा के साथ वर्तमान ऑब्जेक्ट को अपडेट करती है।

हस्ताक्षर किए जाने वाले डेटा को पास करके आरंभिक हस्ताक्षरित वस्तु को अपडेट करें update() नीचे के रूप में बाइट सरणी के रूप में विधि।

byte[] bytes = "Hello how are you".getBytes();      

//Adding data to the signature
sign.update(bytes);

चरण 8: हस्ताक्षर की गणना करें

sign() की विधि Signature वर्ग अद्यतन डेटा के हस्ताक्षर बाइट्स लौटाता है।

का उपयोग करके हस्ताक्षर की गणना करें sign() तरीका नीचे दिखाया गया है।

//Calculating the signature
byte[] signature = sign.sign();

Example

निम्नलिखित जावा प्रोग्राम उपयोगकर्ता के एक संदेश को स्वीकार करता है और दिए गए संदेश के लिए एक डिजिटल हस्ताक्षर बनाता है।

import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.Signature;
import java.util.Scanner;

public class CreatingDigitalSignature {
   public static void main(String args[]) throws Exception {
      //Accepting text from user
      Scanner sc = new Scanner(System.in);
      System.out.println("Enter some text");
      String msg = sc.nextLine();
      
      //Creating KeyPair generator object
      KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("DSA");
      
      //Initializing the key pair generator
      keyPairGen.initialize(2048);
      
      //Generate the pair of keys
      KeyPair pair = keyPairGen.generateKeyPair();
      
      //Getting the private key from the key pair
      PrivateKey privKey = pair.getPrivate();
      
      //Creating a Signature object
      Signature sign = Signature.getInstance("SHA256withDSA");
      
      //Initialize the signature
      sign.initSign(privKey);
      byte[] bytes = "msg".getBytes();
      
      //Adding data to the signature
      sign.update(bytes);
      
      //Calculating the signature
      byte[] signature = sign.sign();
      
      //Printing the signature
      System.out.println("Digital signature for given text: "+new String(signature, "UTF8"));
   }
}

Output

उपरोक्त कार्यक्रम निम्नलिखित आउटपुट उत्पन्न करता है -

Enter some text
Hi how are you
Digital signature for given text: 0=@gRD???-?.???? /yGL?i??a!?

आप जावा का उपयोग करके डिजिटल हस्ताक्षर बना सकते हैं और नीचे दिए गए चरणों का पालन करके इसे सत्यापित कर सकते हैं।

चरण 1: एक KeyPairGenerator ऑब्जेक्ट बनाएँ

सृजन करना KeyPairGenerator का उपयोग कर वस्तु getInstance() तरीका नीचे दिखाया गया है।

//Creating KeyPair generator object
KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("DSA");

चरण 2: KeyPairGenerator ऑब्जेक्ट को प्रारंभ करें

KeyPairGenerator क्लास नाम की एक विधि प्रदान करता है initialize()तरीका। इस विधि का उपयोग कुंजी जोड़ी जनरेटर को आरंभ करने के लिए किया जाता है। यह विधि मुख्य आकार का प्रतिनिधित्व करने वाले पूर्णांक मान को स्वीकार करती है।

//Initializing the KeyPairGenerator
keyPairGen.initialize(2048);

चरण 3: KeyPairGenerator उत्पन्न करें

आप उत्पन्न कर सकते हैं KeyPair का उपयोग करते हुए generateKeyPair()तरीका। नीचे दिखाए गए अनुसार इस विधि का उपयोग करके कीपर उत्पन्न करें।

//Generate the pair of keys
KeyPair pair = keyPairGen.generateKeyPair();

चरण 4: जोड़ी से निजी कुंजी प्राप्त करें

का उपयोग कर निजी कुंजी प्राप्त करें getPrivate() तरीका नीचे दिखाया गया है।

//Getting the private key from the key pair
PrivateKey privKey = pair.getPrivate();

चरण 5: एक हस्ताक्षर वस्तु बनाएं

का उपयोग करके हस्ताक्षर वर्ग की एक वस्तु बनाएँ getInstance() तरीका।

//Creating a Signature object
Signature sign = Signature.getInstance("SHA256withDSA");

चरण 6: हस्ताक्षर वस्तु को आरम्भिक करें

//Initialize the signature
sign.initSign(privKey);

चरण 7: हस्ताक्षर ऑब्जेक्ट में डेटा जोड़ें

byte[] bytes = "Hello how are you".getBytes();      

//Adding data to the signature
sign.update(bytes);

चरण 8: हस्ताक्षर की गणना करें

sign() की विधि Signature वर्ग अद्यतन डेटा के हस्ताक्षर बाइट्स लौटाता है।

नीचे दिखाए अनुसार हस्ताक्षर () विधि का उपयोग करके हस्ताक्षर की गणना करें।

//Calculating the signature
byte[] signature = sign.sign();

चरण 9: सत्यापन के लिए हस्ताक्षर वस्तु को आरम्भ करें

एक हस्ताक्षर वस्तु को सत्यापित करने के लिए आपको पहले इसका उपयोग करके इसे इनिशियलाइज़ करना होगा initVerify() विधि यह विधि स्वीकार करती है a PublicKey वस्तु।

इसलिए, साइन का उपयोग करके सत्यापन के लिए हस्ताक्षर ऑब्जेक्ट को इनिशियलाइज़ करें initVerify() तरीका नीचे दिखाया गया है।

//Initializing the signature
sign.initVerify(pair.getPublic());

चरण 10: सत्यापित किए जाने वाले डेटा को अपडेट करें

डेटा के साथ आरंभीकृत (सत्यापन के लिए) अद्यतन करें अद्यतन विधि का उपयोग करके डेटा को सत्यापित किया जाना चाहिए जैसा कि नीचे दिखाया गया है।

//Update the data to be verified
sign.update(bytes);

चरण 11: हस्ताक्षर सत्यापित करें

verify()हस्ताक्षर वर्ग की विधि किसी अन्य हस्ताक्षर वस्तु को स्वीकार करती है और इसे वर्तमान के साथ सत्यापित करती है। यदि कोई मैच होता है, तो यह सही है और यह गलत है।

इस विधि का उपयोग करके हस्ताक्षर सत्यापित करें जैसा कि नीचे दिखाया गया है।

//Verify the signature
boolean bool = sign.verify(signature);

उदाहरण

निम्नलिखित जावा प्रोग्राम उपयोगकर्ता से एक संदेश स्वीकार करता है, दिए गए संदेश के लिए एक डिजिटल हस्ताक्षर बनाता है, और इसे सत्यापित करता है।

import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.Signature;

import java.util.Scanner;

public class SignatureVerification {
   public static void main(String args[]) throws Exception{
      //Creating KeyPair generator object
      KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("DSA");
	      
      //Initializing the key pair generator
      keyPairGen.initialize(2048);
	      
      //Generate the pair of keys
      KeyPair pair = keyPairGen.generateKeyPair();
      
      //Getting the privatekey from the key pair
      PrivateKey privKey = pair.getPrivate();

      //Creating a Signature object
      Signature sign = Signature.getInstance("SHA256withDSA");

      //Initializing the signature
      sign.initSign(privKey);
      byte[] bytes = "Hello how are you".getBytes();
      
      //Adding data to the signature
      sign.update(bytes);
      
      //Calculating the signature
      byte[] signature = sign.sign();      
      
      //Initializing the signature
      sign.initVerify(pair.getPublic());
      sign.update(bytes);
      
      //Verifying the signature
      boolean bool = sign.verify(signature);
      
      if(bool) {
         System.out.println("Signature verified");   
      } else {
         System.out.println("Signature failed");
      }
   }
}

उत्पादन

उपरोक्त कार्यक्रम निम्नलिखित आउटपुट उत्पन्न करता है -

Signature verified

आप दिए गए डेटा को सिफर वर्ग के उपयोग से एन्क्रिप्ट कर सकते हैं javax.cryptoपैकेज। जावा का उपयोग करके दिए गए डेटा को एन्क्रिप्ट करने के लिए नीचे दिए गए चरणों का पालन करें।

चरण 1: एक KeyPairGenerator ऑब्जेक्ट बनाएँ

सृजन करना KeyPairGenerator का उपयोग कर वस्तु getInstance() तरीका नीचे दिखाया गया है।

//Creating KeyPair generator object
KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("DSA");

चरण 2: KeyPairGenerator ऑब्जेक्ट को प्रारंभ करें

//Initializing the KeyPairGenerator
keyPairGen.initialize(2048);

चरण 3: KeyPairGenerator उत्पन्न करें

//Generate the pair of keys
KeyPair pair = keyPairGen.generateKeyPair();

चरण 4: सार्वजनिक कुंजी प्राप्त करें

आप जनरेट की गई कुंजी को जनरेट से प्राप्त कर सकते हैं KeyPair का उपयोग कर वस्तु getPublic() तरीका नीचे दिखाया गया है।

इस विधि का उपयोग करके सार्वजनिक कुंजी प्राप्त करें जैसा कि नीचे दिखाया गया है।

//Getting the public key from the key pair
PublicKey publicKey = pair.getPublic();

चरण 5: एक सिफर ऑब्जेक्ट बनाएं

getInstance() उसकि विधि Cipher वर्ग आवश्यक परिवर्तन का प्रतिनिधित्व करने वाले स्ट्रिंग चर को स्वीकार करता है और एक सिफर ऑब्जेक्ट देता है जो दिए गए परिवर्तन को लागू करता है।

का उपयोग कर सिफर ऑब्जेक्ट बनाएँ getInstance() तरीका नीचे दिखाया गया है।

//Creating a Cipher object
Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");

चरण 6: सिफर ऑब्जेक्ट को प्रारंभ करें

init() की विधि Cipher क्लास दो मापदंडों को एक पूर्णांक पैरामीटर स्वीकार करता है जो ऑपरेशन मोड (एन्क्रिप्ट / डिक्रिप्ट) का प्रतिनिधित्व करता है और, एक कुंजी ऑब्जेक्ट जो सार्वजनिक कुंजी का प्रतिनिधित्व करता है।

का उपयोग करके Cypher वस्तु को आरम्भिक करें init() तरीका नीचे दिखाया गया है।

//Initializing a Cipher object
cipher.init(Cipher.ENCRYPT_MODE, publicKey);

चरण 7: डेटा को सिफर ऑब्जेक्ट में जोड़ें

update() सिफर क्लास की विधि डेटा को दर्शाने वाले बाइट सरणी को स्वीकार करती है और दिए गए डेटा के साथ वर्तमान ऑब्जेक्ट को अपडेट करती है।

डेटा को पास करके आरंभित सिफर ऑब्जेक्ट को अपडेट करें update() नीचे के रूप में बाइट सरणी के रूप में विधि।

//Adding data to the cipher
byte[] input = "Welcome to Tutorialspoint".getBytes();	  
cipher.update(input);

चरण 8: डेटा एन्क्रिप्ट करें

doFinal()सिफर वर्ग की विधि एन्क्रिप्शन ऑपरेशन को पूरा करती है। इसलिए, नीचे दिखाए गए अनुसार इस पद्धति का उपयोग करके एन्क्रिप्शन को समाप्त करें।

//Encrypting the data
byte[] cipherText = cipher.doFinal();

उदाहरण

जावा प्रोग्राम के बाद उपयोगकर्ता से पाठ स्वीकार करता है, आरएसए एल्गोरिथ्म का उपयोग करके इसे एन्क्रिप्ट करता है और, दिए गए पाठ के एन्क्रिप्टेड प्रारूप को प्रिंट करता है।

import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.Signature;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;

public class CipherSample {
   public static void main(String args[]) throws Exception{
      //Creating a Signature object
      Signature sign = Signature.getInstance("SHA256withRSA");
      
      //Creating KeyPair generator object
      KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");
      
      //Initializing the key pair generator
      keyPairGen.initialize(2048);
      
      //Generating the pair of keys
      KeyPair pair = keyPairGen.generateKeyPair();      
	
      //Creating a Cipher object
      Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
        
      //Initializing a Cipher object
      cipher.init(Cipher.ENCRYPT_MODE, pair.getPublic());
	  
      //Adding data to the cipher
      byte[] input = "Welcome to Tutorialspoint".getBytes();	  
      cipher.update(input);
	  
      //encrypting the data
      byte[] cipherText = cipher.doFinal();	 
      System.out.println(new String(cipherText, "UTF8"));
   }
}

उत्पादन

उपरोक्त कार्यक्रम निम्नलिखित आउटपुट उत्पन्न करता है -

Encrypted Text: 
"???:]J_?]???;Xl??????*@??u???r??=T&???_?_??.??i?????(?$_f?zD??????ZGH??g??? g?E:_??bz^??f?~o???t?}??u=uzp\UI????Z??l[?G?3??Y?UAEfKT?f?O??N_?d__?????a_?15%?^? 'p?_?$,9"{??^??y??_?t???,?W?PCW??~??[?$??????e????f?Y-Zi__??_??w?_?&QT??`?`~?[?K_??_???

आप एन्क्रिप्ट किए गए डेटा को सिफर वर्ग के उपयोग से डिक्रिप्ट कर सकते हैं javax.cryptoपैकेज। जावा का उपयोग करके दिए गए डेटा को डिक्रिप्ट करने के लिए नीचे दिए गए चरणों का पालन करें।

चरण 1: एक KeyPairGenerator ऑब्जेक्ट बनाएँ

सृजन करना KeyPairGenerator का उपयोग कर वस्तु getInstance() तरीका नीचे दिखाया गया है।

//Creating KeyPair generator object
KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("DSA");

चरण 2: KeyPairGenerator ऑब्जेक्ट को प्रारंभ करें

//Initializing the KeyPairGenerator
keyPairGen.initialize(2048);

चरण 3: KeyPairGenerator उत्पन्न करें

//Generate the pair of keys
KeyPair pair = keyPairGen.generateKeyPair();

चरण 4: सार्वजनिक कुंजी प्राप्त करें

//Getting the public key from the key pair
PublicKey publicKey = pair.getPublic();

चरण 5: एक सिफर ऑब्जेक्ट बनाएं

का उपयोग कर सिफर ऑब्जेक्ट बनाएँ getInstance() तरीका नीचे दिखाया गया है।

//Creating a Cipher object
Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");

चरण 6: सिफर ऑब्जेक्ट को प्रारंभ करें

init() सिफर वर्ग की विधि दो मापदंडों को स्वीकार करती है

पूर्णांक पैरामीटर ऑपरेशन मोड का प्रतिनिधित्व करता है (एन्क्रिप्ट / डिक्रिप्ट)
सार्वजनिक कुंजी का प्रतिनिधित्व करने वाली प्रमुख वस्तु

का उपयोग करके Cypher वस्तु को आरम्भिक करें init() तरीका नीचे दिखाया गया है।

//Initializing a Cipher object
cipher.init(Cipher.ENCRYPT_MODE, publicKey);

चरण 7: डेटा को सिफर ऑब्जेक्ट में जोड़ें

//Adding data to the cipher
byte[] input = "Welcome to Tutorialspoint".getBytes();	  
cipher.update(input);

चरण 8: डेटा एन्क्रिप्ट करें

//Encrypting the data
byte[] cipherText = cipher.doFinal();

चरण 9: डिक्रिप्शन के लिए सिफर ऑब्जेक्ट को प्रारंभ करें

पिछले चरण में एन्क्रिप्ट किए गए साइबर को डिक्रिप्ट करने के लिए आपको डिक्रिप्शन के लिए इसे इनिशियलाइज़ करना होगा।

इसलिए, जैसा कि नीचे दिखाया गया है, सिफर D.ECRYPT_MODE और PrivateKey ऑब्जेक्ट को पास करके सिफर ऑब्जेक्ट को इनिशियलाइज़ करें।

//Initializing the same cipher for decryption
cipher.init(Cipher.DECRYPT_MODE, pair.getPrivate());

चरण 10: डेटा को डिक्रिप्ट करें

अंत में, एन्क्रिप्टेड पाठ का उपयोग करके डिक्रिप्ट करें doFinal() तरीका नीचे दिखाया गया है।

//Decrypting the text
byte[] decipheredText = cipher.doFinal(cipherText);

उदाहरण

बाद जावा प्रोग्राम उपयोगकर्ता से पाठ स्वीकार करता है, आरएसए एल्गोरिथ्म का उपयोग करके इसे एन्क्रिप्ट करता है और, दिए गए पाठ के सिफर को प्रिंट करता है, सिफर को डिक्रिप्ट करता है और फिर से डिक्रिप्ट किए गए पाठ को प्रिंट करता है।

import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.Signature;

import javax.crypto.Cipher;

public class CipherDecrypt {
   public static void main(String args[]) throws Exception{
	   //Creating a Signature object
      Signature sign = Signature.getInstance("SHA256withRSA");
      
      //Creating KeyPair generator object
      KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");
      
      //Initializing the key pair generator
      keyPairGen.initialize(2048);
      
      //Generate the pair of keys
      KeyPair pair = keyPairGen.generateKeyPair();   
      
      //Getting the public key from the key pair
      PublicKey publicKey = pair.getPublic();  

      //Creating a Cipher object
      Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");

      //Initializing a Cipher object
      cipher.init(Cipher.ENCRYPT_MODE, publicKey);
	  
      //Add data to the cipher
      byte[] input = "Welcome to Tutorialspoint".getBytes();	  
      cipher.update(input);
	  
      //encrypting the data
      byte[] cipherText = cipher.doFinal();	 
      System.out.println( new String(cipherText, "UTF8"));

      //Initializing the same cipher for decryption
      cipher.init(Cipher.DECRYPT_MODE, pair.getPrivate());
      
      //Decrypting the text
      byte[] decipheredText = cipher.doFinal(cipherText);
      System.out.println(new String(decipheredText));
   }
}

उत्पादन

उपरोक्त कार्यक्रम निम्नलिखित आउटपुट उत्पन्न करता है -

Encrypted Text:
]/[?F3?D?p
v?w?!?H???^?A??????P?u??FA?
?
???_?? ???_jMH-??>??OP?'?j?_?n`
?_??'`????o??_GL??g???g_f?????f|???LT?|?Vz_TDu#??\?<b,,?$C2???Bq?#?lDB`??g,^??K?_?v???`}
?;LX?a?_5e???#???_?6?/B&B_???^?__Ap^#_?q?IEh????_?,??*??]~_?_?D?
_y???lp??a?P_U{

Decrypted Text:
Welcome to Tutorialspoint