उपयोगकर्ताओं को इंपोर्ट करें

Firebase Admin SDK टूल, ज़्यादा विशेषाधिकारों के साथ Firebase Authentication में उपयोगकर्ताओं को एक साथ इंपोर्ट करने के लिए, Auth.importUsers() एपीआई उपलब्ध कराता है. यह सुविधा Firebase CLI में भी उपलब्ध है. हालांकि, Admin SDK टूल की मदद से, किसी बाहरी पुष्टि करने वाले सिस्टम या किसी दूसरे Firebase प्रोजेक्ट से, प्रोग्राम के हिसाब से मौजूदा उपयोगकर्ताओं को अपलोड किया जा सकता है. इसके लिए, आपको CSV या JSON फ़ाइलें बनाने की ज़रूरत नहीं होती.

उपयोगकर्ता इंपोर्ट एपीआई से ये फ़ायदे मिलते हैं:

• पासवर्ड को हैश करने के लिए किसी दूसरे एल्गोरिदम का इस्तेमाल करके, उपयोगकर्ताओं को बाहरी पुष्टि करने वाले सिस्टम से माइग्रेट करने की सुविधा.
• उपयोगकर्ताओं को किसी दूसरे Firebase प्रोजेक्ट से माइग्रेट करने की सुविधा.
• एक साथ कई फ़ाइलें इंपोर्ट करने की प्रोसेस को तेज़ और बेहतर बनाने के लिए ऑप्टिमाइज़ेशन. यह कार्रवाई, uid, email, phoneNumber या डुप्लीकेट आइडेंटिफ़ायर की जांच किए बिना उपयोगकर्ताओं को प्रोसेस करती है.
• मौजूदा OAuth उपयोगकर्ताओं (Google, Facebook वगैरह) को माइग्रेट करने या नए उपयोगकर्ता बनाने की सुविधा.
• कस्टम दावों वाले उपयोगकर्ताओं को एक साथ कई बार इंपोर्ट करने की सुविधा.

इस्तेमाल

एक ही API कॉल में ज़्यादा से ज़्यादा 1,000 उपयोगकर्ता इंपोर्ट किए जा सकते हैं. ध्यान दें कि यह ऑपरेशन, तेज़ी के लिए ऑप्टिमाइज़ किया गया है. साथ ही, यह uid, email, phoneNumber, और अन्य यूनीक आइडेंटिफ़ायर के डुप्लीकेट होने की जांच नहीं करता. अगर किसी ऐसे उपयोगकर्ता को इंपोर्ट किया जाता है जो किसी मौजूदा uid से मेल खाता है, तो मौजूदा उपयोगकर्ता की जगह उसे ले लिया जाएगा. अगर किसी उपयोगकर्ता के किसी अन्य फ़ील्ड (उदाहरण के लिए, email) की डुप्लीकेट वैल्यू मौजूद है, तो उसे इंपोर्ट करने पर, एक और उपयोगकर्ता बन जाएगा. इसलिए, इस एपीआई का इस्तेमाल करते समय, आपको यह पक्का करना होगा कि आपने किसी भी यूनीक फ़ील्ड का डुप्लीकेट न बनाया हो.

Node.js

// Up to 1000 users can be imported at once.
const userImportRecords = [
  {
    uid: 'uid1',
    email: '[e-mail]',
    passwordHash: Buffer.from('passwordHash1'),
    passwordSalt: Buffer.from('salt1'),
  },
  {
    uid: 'uid2',
    email: '[e-mail]',
    passwordHash: Buffer.from('passwordHash2'),
    passwordSalt: Buffer.from('salt2'),
  },
  //...
];

Java

// Up to 1000 users can be imported at once.
List<ImportUserRecord> users = new ArrayList<>();
users.add(ImportUserRecord.builder()
    .setUid("uid1")
    .setEmail("[e-mail]")
    .setPasswordHash("passwordHash1".getBytes())
    .setPasswordSalt("salt1".getBytes())
    .build());
users.add(ImportUserRecord.builder()
    .setUid("uid2")
    .setEmail("[e-mail]")
    .setPasswordHash("passwordHash2".getBytes())
    .setPasswordSalt("salt2".getBytes())
    .build());

Python

# Up to 1000 users can be imported at once.
users = [
    auth.ImportUserRecord(
        uid='uid1',
        email='[e-mail]',
        password_hash=b'password_hash_1',
        password_salt=b'salt1'
    ),
    auth.ImportUserRecord(
        uid='uid2',
        email='[e-mail]',
        password_hash=b'password_hash_2',
        password_salt=b'salt2'
    ),
]

शुरू करें

// Up to 1000 users can be imported at once.
var users []*auth.UserToImport
users = append(users, (&auth.UserToImport{}).
	UID("uid1").
	Email("[e-mail]").
	PasswordHash([]byte("passwordHash1")).
	PasswordSalt([]byte("salt1")))
users = append(users, (&auth.UserToImport{}).
	UID("uid2").
	Email("[e-mail]").
	PasswordHash([]byte("passwordHash2")).
	PasswordSalt([]byte("salt2")))

C#

//  Up to 1000 users can be imported at once.
var users = new List<ImportUserRecordArgs>()
{
    new ImportUserRecordArgs()
    {
        Uid = "uid1",
        Email = "[e-mail]",
        PasswordHash = Encoding.ASCII.GetBytes("passwordHash1"),
        PasswordSalt = Encoding.ASCII.GetBytes("salt1"),
    },
    new ImportUserRecordArgs()
    {
        Uid = "uid2",
        Email = "[e-mail]",
        PasswordHash = Encoding.ASCII.GetBytes("passwordHash2"),
        PasswordSalt = Encoding.ASCII.GetBytes("salt2"),
    },
};

इस उदाहरण में, हैश करने के विकल्पों की जानकारी दी गई है, ताकि Firebase अगली बार Firebase Authentication से साइन इन करने पर, इन उपयोगकर्ताओं की पुष्टि सुरक्षित तरीके से कर सके. साइन इन हो जाने के बाद, Firebase उपयोगकर्ता के पासवर्ड को फिर से हैश करता है. इसके लिए, वह Firebase के अंदर मौजूद हैश करने वाले एल्गोरिदम का इस्तेमाल करता है. यहां, हर एल्गोरिदम के लिए ज़रूरी फ़ील्ड के बारे में ज़्यादा जानें.

Firebase Authentication, किसी उपयोगकर्ता से जुड़ी गड़बड़ी होने पर भी, दिए गए उपयोगकर्ताओं की पूरी सूची अपलोड करने की कोशिश करता है. इस ऑपरेशन से, इंपोर्ट किए गए और इंपोर्ट न हो पाए गए डेटा की खास जानकारी वाला नतीजा मिलता है. गड़बड़ी की जानकारी, उपयोगकर्ता के हर उस इंपोर्ट के लिए दी जाती है जो पूरा नहीं हो पाता.

Node.js

getAuth()
  .importUsers(userImportRecords, {
    hash: {
      algorithm: 'HMAC_SHA256',
      key: Buffer.from('secretKey'),
    },
  })
  .then((userImportResult) => {
    // The number of successful imports is determined via: userImportResult.successCount.
    // The number of failed imports is determined via: userImportResult.failureCount.
    // To get the error details.
    userImportResult.errors.forEach((indexedError) => {
      // The corresponding user that failed to upload.
      console.log(
        'Error ' + indexedError.index,
        ' failed to import: ',
        indexedError.error
      );
    });
  })
  .catch((error) => {
    // Some unrecoverable error occurred that prevented the operation from running.
  });

Java

UserImportOptions options = UserImportOptions.withHash(
    HmacSha256.builder()
        .setKey("secretKey".getBytes())
        .build());
try {
  UserImportResult result = FirebaseAuth.getInstance().importUsers(users, options);
  System.out.println("Successfully imported " + result.getSuccessCount() + " users");
  System.out.println("Failed to import " + result.getFailureCount() + " users");
  for (ErrorInfo indexedError : result.getErrors()) {
    System.out.println("Failed to import user at index: " + indexedError.getIndex()
        + " due to error: " + indexedError.getReason());
  }
} catch (FirebaseAuthException e) {
  // Some unrecoverable error occurred that prevented the operation from running.
}

Python

hash_alg = auth.UserImportHash.hmac_sha256(key=b'secret_key')
try:
    result = auth.import_users(users, hash_alg=hash_alg)
    print('Successfully imported {0} users. Failed to import {1} users.'.format(
        result.success_count, result.failure_count))
    for err in result.errors:
        print('Failed to import {0} due to {1}'.format(users[err.index].uid, err.reason))
except exceptions.FirebaseError:
    # Some unrecoverable error occurred that prevented the operation from running.
    pass

शुरू करें

client, err := app.Auth(ctx)
if err != nil {
	log.Fatalln("Error initializing Auth client", err)
}

h := hash.HMACSHA256{
	Key: []byte("secretKey"),
}
result, err := client.ImportUsers(ctx, users, auth.WithHash(h))
if err != nil {
	log.Fatalln("Unrecoverable error prevented the operation from running", err)
}

log.Printf("Successfully imported %d users\n", result.SuccessCount)
log.Printf("Failed to import %d users\n", result.FailureCount)
for _, e := range result.Errors {
	log.Printf("Failed to import user at index: %d due to error: %s\n", e.Index, e.Reason)
}

C#

var options = new UserImportOptions()
{
    Hash = new HmacSha256()
    {
        Key = Encoding.ASCII.GetBytes("secretKey"),
    },
};

try
{
    UserImportResult result = await FirebaseAuth.DefaultInstance.ImportUsersAsync(users, options);
    Console.WriteLine($"Successfully imported {result.SuccessCount} users");
    Console.WriteLine($"Failed to import {result.FailureCount} users");
    foreach (ErrorInfo indexedError in result.Errors)
    {
        Console.WriteLine($"Failed to import user at index: {indexedError.Index}"
            + $" due to error: {indexedError.Reason}");
    }
}
catch (FirebaseAuthException)
{
    // Some unrecoverable error occurred that prevented the operation from running.
}

अगर पासवर्ड को हैश करने की ज़रूरत नहीं है (फ़ोन नंबर, कस्टम टोकन उपयोगकर्ता, OAuth उपयोगकर्ता वगैरह), तो हैश करने के विकल्प न दें.

Firebase के scrypt हैश किए गए पासवर्ड की मदद से उपयोगकर्ताओं को इंपोर्ट करना

डिफ़ॉल्ट रूप से, Firebase पासवर्ड सेव करने के लिए, scrypt हैशिंग एल्गोरिदम के Firebase के बदले गए वर्शन का इस्तेमाल करता है. बदली गई स्क्रिप्ट की मदद से हैश किए गए पासवर्ड इंपोर्ट करना, उपयोगकर्ताओं को किसी दूसरे मौजूदा Firebase प्रोजेक्ट से माइग्रेट करने के लिए मददगार होता है. ऐसा करने के लिए, मूल प्रोजेक्ट के लिए इंटरनल पैरामीटर तय करने होंगे.

Firebase, हर Firebase प्रोजेक्ट के लिए यूनीक पासवर्ड हैश पैरामीटर जनरेट करता है. इन पैरामीटर को ऐक्सेस करने के लिए, Firebase कंसोल में उपयोगकर्ता टैब पर जाएं. इसके बाद, उपयोगकर्ताओं की टेबल सूची के ऊपरी दाएं कोने में मौजूद ड्रॉप-डाउन से, पासवर्ड हैश पैरामीटर चुनें.

इस एल्गोरिदम के लिए हैश विकल्प बनाने के लिए ज़रूरी पैरामीटर में ये शामिल हैं:

• key: हस्ताक्षर करने वाली कुंजी, आम तौर पर base64 कोड में दी जाती है.
• saltSeparator: आम तौर पर, base64 कोड में नमक को अलग करने के लिए इस्तेमाल किया जाने वाला सेपरेटर(ज़रूरी नहीं).
• rounds: पासवर्ड को हैश करने के लिए इस्तेमाल किए गए राउंड की संख्या.

• memoryCost: इस एल्गोरिदम के लिए ज़रूरी मेमोरी की लागत.

Node.js

getAuth()
  .importUsers(
    [
      {
        uid: 'some-uid',
        email: '[e-mail]',
        // Must be provided in a byte buffer.
        passwordHash: Buffer.from('base64-password-hash', 'base64'),
        // Must be provided in a byte buffer.
        passwordSalt: Buffer.from('base64-salt', 'base64'),
      },
    ],
    {
      hash: {
        algorithm: 'SCRYPT',
        // All the parameters below can be obtained from the Firebase Console's users section.
        // Must be provided in a byte buffer.
        key: Buffer.from('base64-secret', 'base64'),
        saltSeparator: Buffer.from('base64SaltSeparator', 'base64'),
        rounds: 8,
        memoryCost: 14,
      },
    }
  )
  .then((results) => {
    results.errors.forEach((indexedError) => {
      console.log(`Error importing user ${indexedError.index}`);
    });
  })
  .catch((error) => {
    console.log('Error importing users :', error);
  });

Java

try {
  List<ImportUserRecord> users = Collections.singletonList(ImportUserRecord.builder()
      .setUid("some-uid")
      .setEmail("[e-mail]")
      .setPasswordHash(BaseEncoding.base64().decode("password-hash"))
      .setPasswordSalt(BaseEncoding.base64().decode("salt"))
      .build());
  UserImportOptions options = UserImportOptions.withHash(
      Scrypt.builder()
          // All the parameters below can be obtained from the Firebase Console's "Users"
          // section. Base64 encoded parameters must be decoded into raw bytes.
          .setKey(BaseEncoding.base64().decode("base64-secret"))
          .setSaltSeparator(BaseEncoding.base64().decode("base64-salt-separator"))
          .setRounds(8)
          .setMemoryCost(14)
          .build());
  UserImportResult result = FirebaseAuth.getInstance().importUsers(users, options);
  for (ErrorInfo indexedError : result.getErrors()) {
    System.out.println("Failed to import user: " + indexedError.getReason());
  }
} catch (FirebaseAuthException e) {
  System.out.println("Error importing users: " + e.getMessage());
}

Python

users = [
    auth.ImportUserRecord(
        uid='some-uid',
        email='[e-mail]',
        password_hash=base64.urlsafe_b64decode('password_hash'),
        password_salt=base64.urlsafe_b64decode('salt')
    ),
]

# All the parameters below can be obtained from the Firebase Console's "Users"
# section. Base64 encoded parameters must be decoded into raw bytes.
hash_alg = auth.UserImportHash.scrypt(
    key=base64.b64decode('base64_secret'),
    salt_separator=base64.b64decode('base64_salt_separator'),
    rounds=8,
    memory_cost=14
)
try:
    result = auth.import_users(users, hash_alg=hash_alg)
    for err in result.errors:
        print('Failed to import user:', err.reason)
except exceptions.FirebaseError as error:
    print('Error importing users:', error)

शुरू करें

b64URLdecode := func(s string) []byte {
	b, err := base64.URLEncoding.DecodeString(s)
	if err != nil {
		log.Fatalln("Failed to decode string", err)
	}

	return b
}
b64Stddecode := func(s string) []byte {
	b, err := base64.StdEncoding.DecodeString(s)
	if err != nil {
		log.Fatalln("Failed to decode string", err)
	}
	return b
}
// Users retrieved from Firebase Auth's backend need to be base64URL decoded
users := []*auth.UserToImport{
	(&auth.UserToImport{}).
		UID("some-uid").
		Email("[e-mail]").
		PasswordHash(b64URLdecode("password-hash")).
		PasswordSalt(b64URLdecode("salt")),
}

// All the parameters below can be obtained from the Firebase Console's "Users"
// section. Base64 encoded parameters must be decoded into raw bytes.
h := hash.Scrypt{
	Key:           b64Stddecode("base64-secret"),
	SaltSeparator: b64Stddecode("base64-salt-separator"),
	Rounds:        8,
	MemoryCost:    14,
}
result, err := client.ImportUsers(ctx, users, auth.WithHash(h))
if err != nil {
	log.Fatalln("Error importing users", err)
}
for _, e := range result.Errors {
	log.Println("Failed to import user", e.Reason)
}

C#

try
{
    var users = new List<ImportUserRecordArgs>()
    {
        new ImportUserRecordArgs()
        {
            Uid = "some-uid",
            Email = "[e-mail]",
            PasswordHash = Encoding.ASCII.GetBytes("password-hash"),
            PasswordSalt = Encoding.ASCII.GetBytes("salt"),
        },
    };

    var options = new UserImportOptions()
    {
        // All the parameters below can be obtained from the Firebase Console's "Users"
        // section. Base64 encoded parameters must be decoded into raw bytes.
        Hash = new Scrypt()
        {
            Key = Encoding.ASCII.GetBytes("base64-secret"),
            SaltSeparator = Encoding.ASCII.GetBytes("base64-salt-separator"),
            Rounds = 8,
            MemoryCost = 14,
        },
    };

    UserImportResult result = await FirebaseAuth.DefaultInstance.ImportUsersAsync(users, options);
    foreach (ErrorInfo indexedError in result.Errors)
    {
        Console.WriteLine($"Failed to import user: {indexedError.Reason}");
    }
}
catch (FirebaseAuthException e)
{
    Console.WriteLine($"Error importing users: {e.Message}");
}

स्टैंडर्ड स्क्रिप्ट हैश किए गए पासवर्ड वाले उपयोगकर्ताओं को इंपोर्ट करना

Firebase Authentication, स्टैंडर्ड स्क्रिप्ट एल्गोरिदम के साथ-साथ, बदले गए वर्शन (ऊपर) के साथ भी काम करता है. स्टैंडर्ड स्क्रिप्ट एल्गोरिदम के लिए, हैश करने के इन पैरामीटर की ज़रूरत होती है:

• memoryCost: हैशिंग एल्गोरिदम के लिए सीपीयू/मेमोरी की लागत.
• parallelization: हैश एल्गोरिदम को एक साथ चलाना.
• blockSize: हैशिंग एल्गोरिदम का ब्लॉक साइज़ (आम तौर पर 8).

• derivedKeyLength: हैशिंग एल्गोरिदम से मिली पासकोड की लंबाई

Node.js

getAuth()
  .importUsers(
    [
      {
        uid: 'some-uid',
        email: '[e-mail]',
        // Must be provided in a byte buffer.
        passwordHash: Buffer.from('password-hash'),
        // Must be provided in a byte buffer.
        passwordSalt: Buffer.from('salt'),
      },
    ],
    {
      hash: {
        algorithm: 'STANDARD_SCRYPT',
        memoryCost: 1024,
        parallelization: 16,
        blockSize: 8,
        derivedKeyLength: 64,
      },
    }
  )
  .then((results) => {
    results.errors.forEach((indexedError) => {
      console.log(`Error importing user ${indexedError.index}`);
    });
  })
  .catch((error) => {
    console.log('Error importing users :', error);
  });

Java

try {
  List<ImportUserRecord> users = Collections.singletonList(ImportUserRecord.builder()
      .setUid("some-uid")
      .setEmail("[e-mail]")
      .setPasswordHash("password-hash".getBytes())
      .setPasswordSalt("salt".getBytes())
      .build());
  UserImportOptions options = UserImportOptions.withHash(
      StandardScrypt.builder()
          .setMemoryCost(1024)
          .setParallelization(16)
          .setBlockSize(8)
          .setDerivedKeyLength(64)
          .build());
  UserImportResult result = FirebaseAuth.getInstance().importUsers(users, options);
  for (ErrorInfo indexedError : result.getErrors()) {
    System.out.println("Failed to import user: " + indexedError.getReason());
  }
} catch (FirebaseAuthException e) {
  System.out.println("Error importing users: " + e.getMessage());
}

Python

users = [
    auth.ImportUserRecord(
        uid='some-uid',
        email='[e-mail]',
        password_hash=b'password_hash',
        password_salt=b'salt'
    ),
]

hash_alg = auth.UserImportHash.standard_scrypt(
    memory_cost=1024, parallelization=16, block_size=8, derived_key_length=64)
try:
    result = auth.import_users(users, hash_alg=hash_alg)
    for err in result.errors:
        print('Failed to import user:', err.reason)
except exceptions.FirebaseError as error:
    print('Error importing users:', error)

शुरू करें

users := []*auth.UserToImport{
	(&auth.UserToImport{}).
		UID("some-uid").
		Email("[e-mail]").
		PasswordHash([]byte("password-hash")).
		PasswordSalt([]byte("salt")),
}
h := hash.StandardScrypt{
	MemoryCost:       1024,
	Parallelization:  16,
	BlockSize:        8,
	DerivedKeyLength: 64,
}
result, err := client.ImportUsers(ctx, users, auth.WithHash(h))
if err != nil {
	log.Fatalln("Error importing users", err)
}
for _, e := range result.Errors {
	log.Println("Failed to import user", e.Reason)
}

C#

try
{
    var users = new List<ImportUserRecordArgs>()
    {
        new ImportUserRecordArgs()
        {
            Uid = "some-uid",
            Email = "[e-mail]",
            PasswordHash = Encoding.ASCII.GetBytes("password-hash"),
            PasswordSalt = Encoding.ASCII.GetBytes("salt"),
        },
    };

    var options = new UserImportOptions()
    {
        Hash = new StandardScrypt()
        {
            MemoryCost = 1024,
            Parallelization = 16,
            BlockSize = 8,
            DerivedKeyLength = 64,
        },
    };

    UserImportResult result = await FirebaseAuth.DefaultInstance.ImportUsersAsync(users, options);
    foreach (ErrorInfo indexedError in result.Errors)
    {
        Console.WriteLine($"Failed to import user: {indexedError.Reason}");
    }
}
catch (FirebaseAuthException e)
{
    Console.WriteLine($"Error importing users: {e.Message}");
}

HMAC हैश किए गए पासवर्ड वाले उपयोगकर्ताओं को इंपोर्ट करना

HMAC हैशिंग एल्गोरिदम में ये शामिल हैं: HMAC_MD5, HMAC_SHA1, HMAC_SHA256, और HMAC_SHA512. इन हैशिंग एल्गोरिदम के लिए, आपको हैश साइनर की कुंजी देनी होगी.

Node.js

getAuth()
  .importUsers(
    [
      {
        uid: 'some-uid',
        email: '[e-mail]',
        // Must be provided in a byte buffer.
        passwordHash: Buffer.from('password-hash'),
        // Must be provided in a byte buffer.
        passwordSalt: Buffer.from('salt'),
      },
    ],
    {
      hash: {
        algorithm: 'HMAC_SHA256',
        // Must be provided in a byte buffer.
        key: Buffer.from('secret'),
      },
    }
  )
  .then((results) => {
    results.errors.forEach((indexedError) => {
      console.log(`Error importing user ${indexedError.index}`);
    });
  })
  .catch((error) => {
    console.log('Error importing users :', error);
  });

Java

try {
  List<ImportUserRecord> users = Collections.singletonList(ImportUserRecord.builder()
      .setUid("some-uid")
      .setEmail("[e-mail]")
      .setPasswordHash("password-hash".getBytes())
      .setPasswordSalt("salt".getBytes())
      .build());
  UserImportOptions options = UserImportOptions.withHash(
      HmacSha256.builder()
          .setKey("secret".getBytes())
          .build());
  UserImportResult result = FirebaseAuth.getInstance().importUsers(users, options);
  for (ErrorInfo indexedError : result.getErrors()) {
    System.out.println("Failed to import user: " + indexedError.getReason());
  }
} catch (FirebaseAuthException e) {
  System.out.println("Error importing users: " + e.getMessage());
}

Python

users = [
    auth.ImportUserRecord(
        uid='some-uid',
        email='[e-mail]',
        password_hash=b'password_hash',
        password_salt=b'salt'
    ),
]

hash_alg = auth.UserImportHash.hmac_sha256(key=b'secret')
try:
    result = auth.import_users(users, hash_alg=hash_alg)
    for err in result.errors:
        print('Failed to import user:', err.reason)
except exceptions.FirebaseError as error:
    print('Error importing users:', error)

शुरू करें

users := []*auth.UserToImport{
	(&auth.UserToImport{}).
		UID("some-uid").
		Email("[e-mail]").
		PasswordHash([]byte("password-hash")).
		PasswordSalt([]byte("salt")),
}
h := hash.HMACSHA256{
	Key: []byte("secret"),
}
result, err := client.ImportUsers(ctx, users, auth.WithHash(h))
if err != nil {
	log.Fatalln("Error importing users", err)
}
for _, e := range result.Errors {
	log.Println("Failed to import user", e.Reason)
}

C#

try
{
    var users = new List<ImportUserRecordArgs>()
    {
        new ImportUserRecordArgs()
        {
            Uid = "some-uid",
            Email = "[e-mail]",
            PasswordHash = Encoding.ASCII.GetBytes("password-hash"),
            PasswordSalt = Encoding.ASCII.GetBytes("salt"),
        },
    };

    var options = new UserImportOptions()
    {
        Hash = new HmacSha256()
        {
            Key = Encoding.ASCII.GetBytes("secret"),
        },
    };

    UserImportResult result = await FirebaseAuth.DefaultInstance.ImportUsersAsync(users, options);
    foreach (ErrorInfo indexedError in result.Errors)
    {
        Console.WriteLine($"Failed to import user: {indexedError.Reason}");
    }
}
catch (FirebaseAuthException e)
{
    Console.WriteLine($"Error importing users: {e.Message}");
}

MD5, SHA, और PBKDF हैश वाले पासवर्ड का इस्तेमाल करके उपयोगकर्ताओं को इंपोर्ट करना

MD5, SHA, और PBKDF हैशिंग एल्गोरिदम में ये शामिल हैं: MD5, SHA1, SHA256, SHA512, PBKDF_SHA1, और PBKDF2_SHA256. इन हैशिंग एल्गोरिदम के लिए, आपको पासवर्ड को हैश करने के लिए इस्तेमाल किए जाने वाले राउंड की संख्या देनी होगी. MD5 के लिए 0 से 8192, SHA1, SHA256, और SHA512 के लिए 1 से 8192, और PBKDF_SHA1 और PBKDF2_SHA256 के लिए 0 से 1,20,000 के बीच की संख्या देनी होगी.

Node.js

getAuth()
  .importUsers(
    [
      {
        uid: 'some-uid',
        email: '[e-mail]',
        // Must be provided in a byte buffer.
        passwordHash: Buffer.from('password-hash'),
        // Must be provided in a byte buffer.
        passwordSalt: Buffer.from('salt'),
      },
    ],
    {
      hash: {
        algorithm: 'PBKDF2_SHA256',
        rounds: 100000,
      },
    }
  )
  .then((results) => {
    results.errors.forEach((indexedError) => {
      console.log(`Error importing user ${indexedError.index}`);
    });
  })
  .catch((error) => {
    console.log('Error importing users :', error);
  });

Java

try {
  List<ImportUserRecord> users = Collections.singletonList(ImportUserRecord.builder()
      .setUid("some-uid")
      .setEmail("[e-mail]")
      .setPasswordHash("password-hash".getBytes())
      .setPasswordSalt("salt".getBytes())
      .build());
  UserImportOptions options = UserImportOptions.withHash(
      Pbkdf2Sha256.builder()
          .setRounds(100000)
          .build());
  UserImportResult result = FirebaseAuth.getInstance().importUsers(users, options);
  for (ErrorInfo indexedError : result.getErrors()) {
    System.out.println("Failed to import user: " + indexedError.getReason());
  }
} catch (FirebaseAuthException e) {
  System.out.println("Error importing users: " + e.getMessage());
}

Python

users = [
    auth.ImportUserRecord(
        uid='some-uid',
        email='[e-mail]',
        password_hash=b'password_hash',
        password_salt=b'salt'
    ),
]

hash_alg = auth.UserImportHash.pbkdf2_sha256(rounds=100000)
try:
    result = auth.import_users(users, hash_alg=hash_alg)
    for err in result.errors:
        print('Failed to import user:', err.reason)
except exceptions.FirebaseError as error:
    print('Error importing users:', error)

शुरू करें

users := []*auth.UserToImport{
	(&auth.UserToImport{}).
		UID("some-uid").
		Email("[e-mail]").
		PasswordHash([]byte("password-hash")).
		PasswordSalt([]byte("salt")),
}
h := hash.PBKDF2SHA256{
	Rounds: 100000,
}
result, err := client.ImportUsers(ctx, users, auth.WithHash(h))
if err != nil {
	log.Fatalln("Error importing users", err)
}
for _, e := range result.Errors {
	log.Println("Failed to import user", e.Reason)
}

C#

try
{
    var users = new List<ImportUserRecordArgs>()
    {
        new ImportUserRecordArgs()
        {
            Uid = "some-uid",
            Email = "[e-mail]",
            PasswordHash = Encoding.ASCII.GetBytes("password-hash"),
            PasswordSalt = Encoding.ASCII.GetBytes("salt"),
        },
    };

    var options = new UserImportOptions()
    {
        Hash = new Pbkdf2Sha256()
        {
            Rounds = 100000,
        },
    };

    UserImportResult result = await FirebaseAuth.DefaultInstance.ImportUsersAsync(users, options);
    foreach (ErrorInfo indexedError in result.Errors)
    {
        Console.WriteLine($"Failed to import user: {indexedError.Reason}");
    }
}
catch (FirebaseAuthException e)
{
    Console.WriteLine($"Error importing users: {e.Message}");
}

BCRYPT हैश वाले पासवर्ड का इस्तेमाल करके उपयोगकर्ताओं को इंपोर्ट करना

BCRYPT हैश वाले पासवर्ड के लिए, हर उपयोगकर्ता के लिए अतिरिक्त हैश पैरामीटर या पासवर्ड के सॉल्ट की ज़रूरत नहीं होती.

Node.js

getAuth()
  .importUsers(
    [
      {
        uid: 'some-uid',
        email: '[e-mail]',
        // Must be provided in a byte buffer.
        passwordHash: Buffer.from('password-hash'),
      },
    ],
    {
      hash: {
        algorithm: 'BCRYPT',
      },
    }
  )
  .then((results) => {
    results.errors.forEach((indexedError) => {
      console.log(`Error importing user ${indexedError.index}`);
    });
  })
  .catch((error) => {
    console.log('Error importing users :', error);
  });

Java

try {
  List<ImportUserRecord> users = Collections.singletonList(ImportUserRecord.builder()
      .setUid("some-uid")
      .setEmail("[e-mail]")
      .setPasswordHash("password-hash".getBytes())
      .setPasswordSalt("salt".getBytes())
      .build());
  UserImportOptions options = UserImportOptions.withHash(Bcrypt.getInstance());
  UserImportResult result = FirebaseAuth.getInstance().importUsers(users, options);
  for (ErrorInfo indexedError : result.getErrors()) {
    System.out.println("Failed to import user: " + indexedError.getReason());
  }
} catch (FirebaseAuthException e) {
  System.out.println("Error importing users: " + e.getMessage());
}

Python

users = [
    auth.ImportUserRecord(
        uid='some-uid',
        email='[e-mail]',
        password_hash=b'password_hash',
        password_salt=b'salt'
    ),
]

hash_alg = auth.UserImportHash.bcrypt()
try:
    result = auth.import_users(users, hash_alg=hash_alg)
    for err in result.errors:
        print('Failed to import user:', err.reason)
except exceptions.FirebaseError as error:
    print('Error importing users:', error)

शुरू करें

users := []*auth.UserToImport{
	(&auth.UserToImport{}).
		UID("some-uid").
		Email("[e-mail]").
		PasswordHash([]byte("password-hash")).
		PasswordSalt([]byte("salt")),
}
h := hash.Bcrypt{}
result, err := client.ImportUsers(ctx, users, auth.WithHash(h))
if err != nil {
	log.Fatalln("Error importing users", err)
}
for _, e := range result.Errors {
	log.Println("Failed to import user", e.Reason)
}

C#

try
{
    var users = new List<ImportUserRecordArgs>()
    {
        new ImportUserRecordArgs()
        {
            Uid = "some-uid",
            Email = "[e-mail]",
            PasswordHash = Encoding.ASCII.GetBytes("password-hash"),
            PasswordSalt = Encoding.ASCII.GetBytes("salt"),
        },
    };

    var options = new UserImportOptions()
    {
        Hash = new Bcrypt(),
    };

    UserImportResult result = await FirebaseAuth.DefaultInstance.ImportUsersAsync(users, options);
    foreach (ErrorInfo indexedError in result.Errors)
    {
        Console.WriteLine($"Failed to import user: {indexedError.Reason}");
    }
}
catch (FirebaseAuthException e)
{
    Console.WriteLine($"Error importing users: {e.Message}");
}

Argon2 हैश वाले पासवर्ड का इस्तेमाल करके उपयोगकर्ताओं को इंपोर्ट करना

Argon2 हैश ऑब्जेक्ट बनाकर, उन उपयोगकर्ता रिकॉर्ड को इंपोर्ट किया जा सकता है जिनमें Argon2 हैश पासवर्ड हैं. ध्यान दें कि फ़िलहाल, यह सुविधा सिर्फ़ Admin Java SDK में काम करती है.

इस एल्गोरिदम के लिए हैश विकल्प बनाने के लिए ज़रूरी पैरामीटर में ये शामिल हैं:

• hashLengthBytes: हैश की लंबाई, बाइट में. यह पूर्णांक के तौर पर दी जाती है
• hashType: Argon2 का इस्तेमाल किया जाने वाला वैरिएंट (ARGON2_D, ARGON2_ID, ARGON2_I)
• parallelism: पैरलल प्रोसेसिंग की डिग्री, जो इंटीजर के तौर पर दी जाती है. यह वैल्यू 1 से 16 के बीच होनी चाहिए
• iterations: यह एक पूर्णांक है, जो यह तय करता है कि कितनी बार दोहराव करना है. यह वैल्यू 1 से 16 के बीच होनी चाहिए
• memoryCostKib: इस एल्गोरिदम के लिए, 32768 से कम कीबीबाइट मेमोरी की ज़रूरत होती है.
• version: Argon2 एल्गोरिदम का वर्शन (VERSION_10 या VERSION_13). ज़रूरी नहीं, अगर यह नहीं बताया गया है, तो डिफ़ॉल्ट रूप से VERSION_13 पर सेट होता है.

• associatedData: इससे जुड़ा अतिरिक्त डेटा, बाइट कलेक्शन के तौर पर दिया जाता है. इसे हैश वैल्यू में जोड़ा जाता है, ताकि सुरक्षा को और बेहतर बनाया जा सके. ज़रूरी नहीं, एपीआई को भेजने से पहले, इस डेटा को base64 में कोड में बदल दिया जाता है.

Java

try {
  List<ImportUserRecord> users = Collections.singletonList(ImportUserRecord.builder()
      .setUid("some-uid")
      .setEmail("[e-mail]")
      .setPasswordHash("password-hash".getBytes())
      .setPasswordSalt("salt".getBytes())
      .build());
  UserImportOptions options = UserImportOptions.withHash(
      Argon2.builder()
          .setHashLengthBytes(512)
          .setHashType(Argon2HashType.ARGON2_ID)
          .setParallelism(8)
          .setIterations(16)
          .setMemoryCostKib(2048)
          .setVersion(Argon2Version.VERSION_10)
          .setAssociatedData("associated-data".getBytes())
          .build());
  UserImportResult result = FirebaseAuth.getInstance().importUsers(users, options);
  for (ErrorInfo indexedError : result.getErrors()) {
    System.out.println("Failed to import user: " + indexedError.getReason());
  }
} catch (FirebaseAuthException e) {
  System.out.println("Error importing users: " + e.getMessage());
}

पासवर्ड के बिना उपयोगकर्ताओं को इंपोर्ट करना

उपयोगकर्ताओं को पासवर्ड के बिना इंपोर्ट किया जा सकता है. जिन उपयोगकर्ताओं के पास पासवर्ड नहीं है उन्हें, OAuth प्रोवाइडर, कस्टम दावे, फ़ोन नंबर वगैरह वाले उपयोगकर्ताओं के साथ इंपोर्ट किया जा सकता है.

Node.js

getAuth()
  .importUsers([
    {
      uid: 'some-uid',
      displayName: 'John Doe',
      email: '[e-mail]',
      photoURL: 'http://www.example.com/12345678/photo.png',
      emailVerified: true,
      phoneNumber: '[phone]',
      // Set this user as admin.
      customClaims: { admin: true },
      // User with Google provider.
      providerData: [
        {
          uid: 'google-uid',
          email: '[e-mail]',
          displayName: 'John Doe',
          photoURL: 'http://www.example.com/12345678/photo.png',
          providerId: 'google.com',
        },
      ],
    },
  ])
  .then((results) => {
    results.errors.forEach((indexedError) => {
      console.log(`Error importing user ${indexedError.index}`);
    });
  })
  .catch((error) => {
    console.log('Error importing users :', error);
  });

Java

try {
  List<ImportUserRecord> users = Collections.singletonList(ImportUserRecord.builder()
      .setUid("some-uid")
      .setDisplayName("John Doe")
      .setEmail("[e-mail]")
      .setPhotoUrl("http://www.example.com/12345678/photo.png")
      .setEmailVerified(true)
      .setPhoneNumber("[phone]")
      .putCustomClaim("admin", true) // set this user as admin
      .addUserProvider(UserProvider.builder() // user with Google provider
          .setUid("google-uid")
          .setEmail("[e-mail]")
          .setDisplayName("John Doe")
          .setPhotoUrl("http://www.example.com/12345678/photo.png")
          .setProviderId("google.com")
          .build())
      .build());
  UserImportResult result = FirebaseAuth.getInstance().importUsers(users);
  for (ErrorInfo indexedError : result.getErrors()) {
    System.out.println("Failed to import user: " + indexedError.getReason());
  }
} catch (FirebaseAuthException e) {
  System.out.println("Error importing users: " + e.getMessage());
}

Python

users = [
    auth.ImportUserRecord(
        uid='some-uid',
        display_name='John Doe',
        email='[e-mail]',
        photo_url='http://www.example.com/12345678/photo.png',
        email_verified=True,
        phone_number='[phone]',
        custom_claims={'admin': True}, # set this user as admin
        provider_data=[ # user with Google provider
            auth.UserProvider(
                uid='google-uid',
                email='[e-mail]',
                display_name='John Doe',
                photo_url='http://www.example.com/12345678/photo.png',
                provider_id='google.com'
            )
        ],
    ),
]
try:
    result = auth.import_users(users)
    for err in result.errors:
        print('Failed to import user:', err.reason)
except exceptions.FirebaseError as error:
    print('Error importing users:', error)

शुरू करें

users := []*auth.UserToImport{
	(&auth.UserToImport{}).
		UID("some-uid").
		DisplayName("John Doe").
		Email("[e-mail]").
		PhotoURL("http://www.example.com/12345678/photo.png").
		EmailVerified(true).
		PhoneNumber("[phone]").
		CustomClaims(map[string]interface{}{"admin": true}). // set this user as admin
		ProviderData([]*auth.UserProvider{                   // user with Google provider
			{
				UID:         "google-uid",
				Email:       "[e-mail]",
				DisplayName: "John Doe",
				PhotoURL:    "http://www.example.com/12345678/photo.png",
				ProviderID:  "google.com",
			},
		}),
}
result, err := client.ImportUsers(ctx, users)
if err != nil {
	log.Fatalln("Error importing users", err)
}
for _, e := range result.Errors {
	log.Println("Failed to import user", e.Reason)
}

C#

try
{
    var users = new List<ImportUserRecordArgs>()
    {
        new ImportUserRecordArgs()
        {
            Uid = "some-uid",
            DisplayName = "John Doe",
            Email = "[e-mail]",
            PhotoUrl = "http://www.example.com/12345678/photo.png",
            EmailVerified = true,
            PhoneNumber = "[phone]",
            CustomClaims = new Dictionary<string, object>()
            {
                { "admin", true }, // set this user as admin
            },
            UserProviders = new List<UserProvider>
            {
                new UserProvider() // user with Google provider
                {
                    Uid = "google-uid",
                    Email = "[e-mail]",
                    DisplayName = "John Doe",
                    PhotoUrl = "http://www.example.com/12345678/photo.png",
                    ProviderId = "google.com",
                },
            },
        },
    };

    UserImportResult result = await FirebaseAuth.DefaultInstance.ImportUsersAsync(users);
    foreach (ErrorInfo indexedError in result.Errors)
    {
        Console.WriteLine($"Failed to import user: {indexedError.Reason}");
    }
}
catch (FirebaseAuthException e)
{
    Console.WriteLine($"Error importing users: {e.Message}");
}