Codificando una contraseña con sal antes de hacer hash. ¿Buena idea o innecesaria?

1

Estoy actualizando un sitio de ASP clásico heredado y necesito almacenar contraseñas, así que, naturalmente, estoy siendo un poco cauteloso sobre cómo hacerlo, dadas las limitaciones de ASP clásico.

Estoy usando tanto sal como pimienta (la pimienta es una constante almacenada en el servidor, no en la base de datos), y me pregunto si hay algún beneficio para mezclar / mezclar los caracteres de " pimienta + contraseña + sal "¿cuerda antes de hashing?

He escrito una función que puede codificar una cadena de cualquier longitud en función de una secuencia de números predefinida (secreta) (la secuencia también se almacena en el servidor, no en la base de datos). Por lo tanto, la función siempre devolverá el mismo valor aleatorizado en lugar de un valor aleatorio aleatorizado (que, por supuesto, no sería útil).

He estado leyendo mucho acerca de la creación de contraseñas, pero nunca he visto a nadie que sugiera que se codifique la contraseña antes de hacer hash. Pero para mí, esto parece un gran nivel de seguridad adicional.

¿Solo te preguntas qué piensan los demás?

Aquí está la función scramble (está escrita en VBscript):

Function ScrambleSalt(the_str)

    '// Once you've joined the pepper + password + salt, you pass it through the "ScrambleSalt" function before 
    '// hashing. The "ScrambleSalt" function will scramble any string based on a pre-set sequence of numbers. 
    '// The sequence is imported from a txt file (kept in an offline folder, just like the pepper).

    '// The sequence needs to be an incremental collection of numbers (starting from 1) but in a random order 
    '// and comma delimited. Here's and example with 1 to 50, although the actual sequence uses 1 - 500:

    '// 22,8,21,45,49,42,3,36,11,47,19,9,15,23,40,16,29,31,43,38,44,4,41,13,35,26,17,14,10,28,6,5,34,12,39,1,
    '// 30,46,32,7,27,48,33,25,18,2,50,20,24,37

    '// (^ the numbers 1 to 50 in a random order)

    '// How the scrambling process works (using the above example sequence) is by rearranging the characters in 
    '// the string so that characters 22 appears first, followed by character 8, then character 21 etc, etc... 
    '// the function cycles through the sequence ignoring any numbers that are larger than the length of the 
    '// string until the characters in the string have all been rearranged (scrambled).

    '// If a string is more than 50 characters long, it will be split into individual strings, each containing 
    '// 50 characters (or a remainder in the case of the last string).

    '// So if the length of the string is 120 characters long, it will be split into 3 string:

    '// String 1 = 50 chars (chars 1 - 50)
    '// String 2 = 50 chars (chars 51 - 100)
    '// String 3 = 20 chars (chars 101 - 120)

    '// Each string will be scrambled, then joined back together before being returned by the function. 
    '// Using this method means the function can scramble strings of any length and without limit.

    Dim scramble_sequence, sequence_array, scramble_loop, in_loop_str, scrambled_str
    scramble_sequence = file_get_contents(request.ServerVariables("APPL_PHYSICAL_PATH") & "/../keys/scramble_sequence.txt")
    sequence_array = split(scramble_sequence,",")
    scramble_loop = Ceil(len(the_str),uBound(sequence_array)+1) '// round up
    for fx = 0 to scramble_loop-1
        in_loop_str = mid(the_str,fx*(uBound(sequence_array)+1)+1,uBound(sequence_array)+1)
        for fy = 0 to uBound(sequence_array)
            if int(sequence_array(fy)) =< len(in_loop_str) then
                scrambled_str = scrambled_str & mid(in_loop_str,int(sequence_array(fy)),1)
            end if
        next
    next
    ScrambleSalt = scrambled_str

End Function

function Ceil(dividend, divider) ' for rounding up a number
    if (dividend mod divider) = 0 Then
        Ceil = dividend / divider
    else
        Ceil = Int(dividend / divider) + 1
    end if
End function

function file_get_contents(file_path)
    Set fs = Server.CreateObject("Scripting.FileSystemObject")
    Set f = fs.OpenTextFile(file_path,1)
        file_get_contents = f.ReadAll
    f.Close : Set f = Nothing : Set fs = Nothing
end function

Un ejemplo de la función anterior en acción

pepper value used for this example = "XC3Qpm7CNXauwAbX"
scramble sequence used for this example = "9,39,50,43,18,11,36,7,29,41,27,34,12,45,1,14,42,13,6,4,25,19,24,33,30,20,23,10,46,16,49,38,15,5,17,8,47,28,26,3,2,40,37,44,35,32,48,22,31,21"

password = "p@44w0rd"
salt = "G1sWNd0andiIhOYA"

concatenated pepper+password+salt:
XC3Qpm7CNXauwAbXp@44w0rdG1sWNd0andiIhOYA

scrambled using the example sequence:
NY@aI7NsduXAwmQG4dnd4rXXObppCW13CAhia00w

SHA512 Hash:
9d5a7781eeb815250c55c1a1f172c569b3b6167a48951c819e4982bea9b84bd8ecad6a417ff8f110541a1039ddf1fd8daa61a52a7c401fccae71dda77c607540

Las sales se almacenan junto a las contraseñas con hash, y mi pensamiento detrás de este método es si un pirata informático puede obtener acceso a la base de datos, reconstruir una tabla de arco iris para apuntar a una cuenta individual implementando la sal sería casi imposible dado La contraseña + el valor de la sal está codificado y no solo concatenado, lo que hace que el hash forzado por la fuerza bruta sea casi imposible (por no mencionar el uso de la pimienta). El pirata informático necesitaría acceso al código fuente para incluso intentar forzar con fuerza brutal el hash ... También me doy cuenta de que concatenar una pimienta + contraseña + sal antes del hashing es el estándar aceptado, pero pensé que este podría ser un buen nivel extra De seguridad, si no un poco excesivo.

    
pregunta user2597933 15.10.2017 - 14:19
fuente

1 respuesta

5
  

Pero para mí esto parece un gran nivel de seguridad adicional.

No creo que esto proporcione una seguridad adicional significativa. Si el atacante obtiene acceso a su código de aleatorización y al secreto, necesitará el mismo tiempo para descifrar sus contraseñas, ya que esta función de aleatorización no aumenta el espacio de búsqueda de forzados brutos. Incluso si solo se conocen los algoritmos pero no el secreto de aleatorización, no será tan difícil forzar el secreto, suponiendo que su base de datos de contraseñas sea grande y contenga las contraseñas triviales típicas. En otras palabras: su idea se basa completamente en la oscuridad, es decir, que tanto el algoritmo como la clave de aleatorización (¡en breve!) Son desconocidas para el atacante.

Y, si solo desea agregar más oscuridad confiando en los secretos del lado del servidor, probablemente sea más simple simplemente alargar su tiempo.

Los métodos establecidos para almacenar contraseñas confían en el uso de métodos de hash específicamente diseñados para ser lentos para ralentizar a los atacantes que intentan forzar los hashes de contraseñas capturados por fuerza bruta y, por lo tanto, son robustos incluso si se conocen tanto las contraseñas hash como los métodos hash. Para obtener más información, consulte ¿Cómo hash seguro las contraseñas? .

    
respondido por el Steffen Ullrich 15.10.2017 - 15:03
fuente

Lea otras preguntas en las etiquetas