Besoin d'une alternative plus petite pour GUID pour DB ID, mais toujours uniques et aléatoires pour les URL

[En réponse à l'edit]

Vous devriez envisager de chaînes de requête comme "le mal de l'entrée". Vous avez besoin de programmation pour vérifier que l'utilisateur authentifié est autorisé à voir l'élément demandé.

if( !item456.BelongsTo(user123) )
{
  //Either show them one of their items or a show an error message.
}

Mise à JOUR (4 Février 2017):

Walter Stabosz découvert un bogue dans le code original. Après enquête il y a d'autres bugs découvert, cependant, de nombreux tests et à retravailler le code par moi-même, l'auteur original (CraigTP) a maintenant résolu tous ces problèmes. J'ai mis à jour le code ici avec la bonne version de travail, et vous pouvez également télécharger Visual Studio 2015 solution ici qui contient le "shortcode" la génération de code et de manière assez complète de la suite de tests pour prouver l'exactitude.

Un mécanisme intéressant que j'ai utilisé dans le passé, c'est en interne, il suffit d'utiliser une incrémentation entier/long, mais à la "carte" qui entier à une alphanumérique "code".

Exemple

Console.WriteLine($"1371 as a shortcode is: {ShortCodes.LongToShortCode(1371)}");
Console.WriteLine($"12345 as a shortcode is: {ShortCodes.LongToShortCode(12345)}");
Console.WriteLine($"7422822196733609484 as a shortcode is: {ShortCodes.LongToShortCode(7422822196733609484)}");

Console.WriteLine($"abc as a long is: {ShortCodes.ShortCodeToLong("abc")}");
Console.WriteLine($"ir6 as a long is: {ShortCodes.ShortCodeToLong("ir6")}");
Console.WriteLine($"atnhb4evqqcyx as a long is: {ShortCodes.ShortCodeToLong("atnhb4evqqcyx")}");    

//PLh7lX5fsEKqLgMrI9zCIA   
Console.WriteLine(GuidToShortGuid( Guid.Parse("957bb83c-5f7e-42b0-aa2e-032b23dcc220") ) );      

Code

Le code suivant montre une classe simple qui va changer une longue d'un "code" (et encore!):

public static class ShortCodes
{
//You may change the "shortcode_Keyspace" variable to contain as many or as few characters as you
//please.  The more characters that are included in the "shortcode_Keyspace" constant, the shorter
//the codes you can produce for a given long.
private static string shortcodeKeyspace = "abcdefghijklmnopqrstuvwxyz0123456789";
public static string LongToShortCode(long number)
{
//Guard clause.  If passed 0 as input
//we always return empty string.
if (number == 0)
{
return string.Empty;
}
var keyspaceLength = shortcodeKeyspace.Length;
var shortcodeResult = "";
var numberToEncode = number;
var i = 0;
do
{
i++;
var characterValue = numberToEncode % keyspaceLength == 0 ? keyspaceLength : numberToEncode % keyspaceLength;
var indexer = (int) characterValue - 1;
shortcodeResult = shortcodeKeyspace[indexer] + shortcodeResult;
numberToEncode = ((numberToEncode - characterValue) / keyspaceLength);
}
while (numberToEncode != 0);
return shortcodeResult;
}
public static long ShortCodeToLong(string shortcode)
{
var keyspaceLength = shortcodeKeyspace.Length;
long shortcodeResult = 0;
var shortcodeLength = shortcode.Length;
var codeToDecode = shortcode;
foreach (var character in codeToDecode)
{
shortcodeLength--;
var codeChar = character;
var codeCharIndex = shortcodeKeyspace.IndexOf(codeChar);
if (codeCharIndex < 0)
{
//The character is not part of the keyspace and so entire shortcode is invalid.
return 0;
}
try
{
checked
{
shortcodeResult += (codeCharIndex + 1) * (long) (Math.Pow(keyspaceLength, shortcodeLength));
}
}
catch(OverflowException)
{
//We've overflowed the maximum size for a long (possibly the shortcode is invalid or too long).
return 0;
}
}
return shortcodeResult;
}
}

}

C'est essentiellement votre propre baseX système de numérotation (où X est le nombre de caractères dans le shortCode_Keyspace constante.

Pour rendre les choses unpredicable, démarrez votre interne de l'incrémentation de la numérotation à partir d'autre chose que 1 ou 0 (j'.e commencer à 184723) et aussi changer l'ordre des caractères dans le shortCode_Keyspace constante (c'est à dire utiliser les lettres A-Z et les chiffres de 0 à 9, mais scamble leur ordre au sein de la chaîne constante. Cela vous aidera à faire de chaque code quelque peu imprévisible.

Si vous utilisez ce pour "protéger" quoi que ce soit, c'est toujours la sécurité par l'obscurité, et si un utilisateur donné peut observer assez de ces codes générés, ils peuvent prédire le code pertinent pour une longue. La "sécurité" (si on peut appeler ça comme ça) c'est que le shortCode_Keyspace constante est brouillé, et reste secret.

EDIT:
Si vous voulez juste pour générer un GUID, et de le transformer en quelque chose qui est toujours unique, mais contient un peu moins de personnages, cette petite fonction fera l'affaire:

public static string GuidToShortGuid(Guid gooid)
{
string encoded = Convert.ToBase64String(gooid.ToByteArray());
encoded = encoded.Replace("/", "_").Replace("+", "-");
return encoded.Substring(0, 22);
}

Vous pourriez générer aléatoirement un nombre. Vérifier que ce numéro n'est pas déjà dans la base de données et l'utiliser. Si vous souhaitez qu'il apparaisse comme une chaîne de caractères aléatoires, vous pourriez convertir en hexadécimal, de sorte que vous obtenez Un F-là, tout comme dans votre exemple.

Prendre votre auto-incrément ID, et HMAC-SHA1 avec un secret connu seulement de vous. Cela va générer un hasard-à la recherche de 160 bits qui cachent les vrais ID incrémentielle. Ensuite, prendre un préfixe de longueur qui rend les collisions suffisamment rare pour votre application---dire 64-bits, ce qui peut encoder en 8 caractères. Utiliser ce que votre chaîne.

HMAC permettra de garantir que personne ne peut la carte de bits indiqué retour de la sous-nombre. Par malaxage d'un auto-incrément ID, vous pouvez être sûr qu'il sera unique. Si votre risque de collisions vient de la probabilité d'un 64 bits partielle de collision en SHA1. Avec cette méthode, vous pouvez prédéterminer si vous avez des collisions en pré-production de toutes les chaînes aléatoires que cette méthode qui génèrent (par exemple le nombre de lignes que vous attendez) et de contrôle.

Bien sûr, si vous êtes prêt à spécifier une condition unique sur votre colonne de base de données, puis il suffit de générer de façon totalement aléatoire fonctionnera tout aussi bien. Vous avez juste à être prudent sur la source de l'aléatoire.

J'ai juste eu une idée et je vois Greg également souligné cela. J'ai de l'utilisateur stocké dans la session avec un nom d'utilisateur. Quand j'ai créer ma requête, je vais rejoindre sur la table des Utilisateurs avec cet ID d'Utilisateur, si l'ensemble est vide, alors nous savons qu'il a été le piratage de l'adresse URL et je peux rediriger vers une page d'erreur.

Combien de temps est trop long? Vous pouvez convertir le GUID à Base 64, qui finit par rendre tout à fait un peu plus courte.