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

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

यूज़र इंपोर्ट एपीआई के ये फ़ायदे हैं:

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

इस्तेमाल किए जाने से जुड़ी जानकारी

एक एपीआई कॉल में ज़्यादा से ज़्यादा 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 से पुष्टि करने की सुविधा से साइन इन करने की कोशिश करे, तब सुरक्षित तरीके से पुष्टि हो सके. साइन-इन करने के बाद, Firebase इंटरनल Firebase हैशिंग एल्गोरिदम की मदद से, उपयोगकर्ता के पासवर्ड को फिर से हैश करता है. नीचे हर एल्गोरिदम के हिसाब से ज़रूरी फ़ील्ड के बारे में ज़्यादा जानें.

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

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 के हैश किए गए पासवर्ड से उपयोगकर्ताओं को इंपोर्ट करें

डिफ़ॉल्ट रूप से, Firebase पासवर्ड सेव करने के लिए स्क्रिप्ट हैशिंग एल्गोरिदम के बदले गए 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 से पुष्टि करने की सुविधा, स्टैंडर्ड स्क्रिप्ट एल्गोरिदम के साथ-साथ, बदले गए वर्शन (ऊपर) के साथ काम करती है. स्टैंडर्ड स्क्रिप्टिंग एल्गोरिदम के लिए, ये हैशिंग पैरामीटर ज़रूरी हैं:

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

• 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_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 से 120000 के बीच) की संख्या देनी होगी.

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}");
}

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

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

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

• hashLengthBytes: पूर्णांक के तौर पर दी गई हैश की लंबाई बाइट में
• hashType: इस्तेमाल किया जाने वाला Argan2 वैरिएंट (ARGON2_D, ARGON2_ID, ARGON2_I)
• parallelism: पैरललिज़म की डिग्री, जिसे पूर्णांक के तौर पर दिया जाता है. बुक किए जाने वाले अपॉइंटमेंट की संख्या, हर दिन के लिए 1 से 16 के बीच होनी चाहिए
• iterations: परफ़ॉर्म करने के लिए इटरेशन की संख्या, जिसे पूर्णांक के तौर पर दिया जाता है. बुक किए जाने वाले अपॉइंटमेंट की संख्या, हर दिन के लिए 1 से 16 के बीच होनी चाहिए
• memoryCostKib: इस एल्गोरिदम के लिए, किबीबाइट में ज़रूरी मेमोरी लागत 32768 से कम होनी चाहिए.
• version: Argan2 एल्गोरिदम का वर्शन (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}");
}