¿Cómo puedo validar el número de seguridad social de los EE. UU.?

Question

¿Alguien sabe cómo mejorar esta función? No estoy preocupado por acortar el código, estoy seguro de que esto podría hacerse con mejor expresión regular, estoy más preocupado por la lógica correcta. Me ha costado mucho encontrar documentación para los números del SSN. La mayoría de las reglas que uso a continuación provienen de otros programadores que trabajan en la industria del crédito (no se citan fuentes).

1. ¿Hay reglas adicionales que usted conoce de ?
2. ¿Sabe si algo de esto está mal?
3. ¿Puede ubicar sus fuentes?

¡Gracias por cualquier idea!

public static bool isSSN(string ssn) 
    { 
     Regex rxBadSSN = new Regex(@"(\d)\1\1\1\1\1\1\1\1"); 

     //Must be 9 bytes 
     if(ssn.Trim().Length != 9) 
      return false; 

     //Must be numeric 
     if(!isNumeric(ssn)) 
      return false; 

     //Must be less than 772999999 
     if((Int32)Double.Parse(ssn.Substring(0,3)) > 772) 
     { 
      //Check for Green Card Temp SSN holders 
      // Could be 900700000 
      //   900800000 
      if(ssn.Substring(0,1) != "9") 
       return false; 

      if(ssn.Substring(3,1) != "7" && ssn.Substring(3,1) != "8") 
       return false; 
     } 

     //Obviously Fake! 
     if(ssn == "123456789") 
      return false; 

     //Try again! 
     if(ssn == "123121234") 
      return false; 

     //No single group can have all zeros 
     if(ssn.Substring(0,3) == "000") 
      return false; 
     if(ssn.Substring(3,2) == "00") 
      return false; 
     if(ssn.Substring(5,4) == "0000") 
      return false; 

     //Check to make sure the SSN number is not repeating 
     if (rxBadSSN.IsMatch(ssn)) 
      return false; 

     return true; 
    } 

Answer 1

ACTUALIZACIÓN

El 25 de junio de 2011, el SSA cambió el proceso de asignación de SSN a "aleatorización SSN". [27] La aleatorización de SSN afecta el proceso de asignación de SSN de las siguientes maneras:

Elimina la importancia geográfica de los primeros tres dígitos del SSN, anteriormente denominado Número de área, al no asignar más los Números de Área para la asignación a individuos en estados específicos. Elimina la importancia del número de grupo más alto y, como resultado, la lista de grupos altos se congela en el tiempo y se puede usar para la validación de los SSN emitidos antes de la fecha de implementación de la asignación al azar. Los Números de Área previamente no asignados se han introducido para la asignación excluyendo los Números de Área 000, 666 y 900-999.

Nuevas reglas

• El número de la Seguridad Social es un número de nueve dígitos en el formato de "AAA-GG-SSSS". El número está dividido en tres partes.
• Los dos dígitos medios son el número de grupo. Los números de grupo van del 01 al 99.
• Los últimos cuatro dígitos son números de serie. Representan una secuencia numérica recta de dígitos de 0001 a 9999 dentro del grupo.
• Algunos números especiales no se asignan:
  • números con ceros en cualquier grupo de dígitos (000 - ## - ####, ### - 00 - ####, #### # -0000).
  • Números con 666 o 900-999 (Número de identificación del contribuyente individual) en el primer grupo de dígitos.
• SSNs used in advertising han hecho que esos números no sean válidos.

http://en.wikipedia.org/wiki/Social_Security_number#Structure

respuesta anterior

Aquí está la most-complete description de la composición de un SSN que he encontrado.

Answer 2

Es todo en socialsecurity.gov: Numbering scheme, allocations, highest numbers actualizan mensualmente.

Answer 3

Obviamente, esta es una publicación anterior, pero encontré algunas formas de acortarla. También hay algunos números específicos para invalidar de acuerdo con este enlace: http://www.snopes.com/business/taxes/woolworth.asp

Así es como lo hice. Podría haber usado expresiones regulares para repetir números, pero con las específicas para invalidar, también podríamos agregar las cinco a la lista (más de 5 invalidarán de todos modos debido a la validación del número de área). También omití isNumeric (ssn) porque el campo es numérico y ya elimina los caracteres antes de llamar a la función de validación.

function validateSSN(ssn) { 
    // validate format (no all zeroes, length 9 
    if (!ssn.match(/^[1-9][0-9]{2}[1-9][0-9]{1}[1-9][0-9]{3}/) 
      || ssn.length!=9) return false; 

    // validate area number (1st 3 digits) 
    var area=parseInt(ssn.substring(0, 3)); 
    // standard  railroad numbers (pre-1963) 
    if (area>649 && !(area>=700 && area<=728)) return false; 

    // disallow specific invalid number 
    if (ssn=='078051120' || // fun fact: some idiot boss put his 
          // secretary's ssn in wallets he sold, 
          // now this is 40000 people's ssn 
     ssn=='219099999' || // was used in an ad by the Social Security 
          // Administration 
     ssn=='123456789' || // although valid it's not yet assigned and 
          // you're not likely to meet the person who 
          // will get it 
     ssn=='123121234' || // probably is assigned to someone but more 
          // likely to find someone trying to fake a 
          // number (next is same) 
     ssn=='321214321' || // all the rest are likely potentially 
          // valid, but most likely these numbers are 
          // abused 
     ssn=='111111111' || 
     ssn=='222222222' || 
     ssn=='333333333' || 
     ssn=='444444444' || 
     ssn=='555555555') return false; 

    return true; 
} 

Answer 4

A partir de 2011 SSN están completamente al azar (http://www.socialsecurity.gov/employer/randomization.html)

Las únicas reglas reales que quedan son:

• no puede empezar con 900-999 (aunque el número de identificación de contribuyente individual, que puede ser utilizado como un SSN por residentes temporales e indocumentados/DACA/DAPA inmigrantes en algunas situaciones, está en el mismo formato y comienza con 9)
• No puede comenzar con 666
• no puede comenzar con 000
• Debe ser de 9 dígitos numéricos o 11 con los 2 guiones
• No puede ser cualquiera de las falsificaciones conocidas;
  • "078051120" — Woolworth Monedero Fiasco
  • "219099999" — fue utilizada en un anuncio por la Administración de Seguridad Social
• Mucha gente excluir la repetición de un número secuencial también, aunque estos son ahora técnicamente válido, y lo siento por el pobre idiota que tiene asignados estos.

Answer 5

A partir de la asignación al azar de los números de seguridad social posteriores al 911, las entradas en la serie 900 e incluso 666 son ahora números potencialmente válidos.

Las únicas ciertas cosas en este punto en el tiempo parecen ser:
el primer grupo de 3 nunca habrá 000
el par grupo medio nunca será 00
y los cuatro últimos nunca habrá 0000

Puede realizar algunas pruebas probando primero para asegurarse de que el valor numérico de la entrada sea> = 1010001 [y < 1000000000] (un ssan de 001-01-0001 parece ser el más bajo legítimamente asignado). Luego puede proceder a buscar 00 en las posiciones 4 y 5, y 0000 en las últimas cuatro.

Answer 6

Respuesta 5 años después de la pregunta inicial debido a cambios en las reglas de validación por el Social Security Administration.También hay números específicos para invalidar de acuerdo con este link.

Según mi respuesta de casi 2 años, también omití isNumeric (ssn) porque el campo es numérico y ya elimina los caracteres antes de llamar a la función de validación.

// validate social security number with ssn parameter as string 
function validateSSN(ssn) { 
    // find area number (1st 3 digits, no longer actually signifies area) 
    var area = parseInt(ssn.substring(0, 3)); 
    return (
     // 9 characters 
     ssn.length === 9 && 
     // no set can start with zero 
     ssn.match(/^[1-9][0-9]{2}[1-9][0-9]{1}[1-9][0-9]{3}/) && 
     // disallow Satan's minions from becoming residents of the US 
     area !== 666 && 
     // it's over 900 
     area < 900 && 
     // fun fact: some idiot boss put his secretary's ssn in wallets 
     // he sold, now it "belongs" to 40000 people 
     ssn !== '078051120' && 
     // was used in an ad by the Social Security Administration 
     ssn !== '219099999' 
    ); 
} 

De acuerdo con la información actualizada, no hay más controles que realizar.

Answer 7

aquí está mi versión de PHP

/** 
* Validate SSN - must be in format AAA-GG-SSSS or AAAGGSSSS 
* 
* @param $ssn 
* @return bool 
*/ 
function validate_ssn($ssn) { 

    $ssnTrimmed = trim($ssn); 

    // Must be in format AAA-GG-SSSS or AAAGGSSSS 
    if (! preg_match("/^([0-9]{9}|[0-9]{3}-[0-9]{2}-[0-9]{4})$/", $ssnTrimmed)) { 
     return false; 
    } 

    // Split groups into an array 
    $ssnFormatted = (strlen($ssnTrimmed) == 9) ? preg_replace("/^([0-9]{3})([0-9]{2})([0-9]{4})$/", "$1-$2-$3", $ssnTrimmed) : $ssnTrimmed; 
    $ssn_array = explode('-', $ssnFormatted); 

    // number groups must follow these rules: 
    // * no single group can have all 0's 
    // * first group cannot be 666, 900-999 
    // * second group must be 01-99 
    // * third group must be 0001-9999 

    foreach ($ssn_array as $group) { 
     if ($group == 0) { 
      return false; 
     } 
    } 

    if ($ssn_array[0] == 666 || $ssn_array[0] > 899) { 
     return false; 
    } 

    return true; 
} 

Answer 8

Sé que esto es una cuestión de edad, sino por el bien de los demás en busca de respuestas, pensé que había que añadir una función de JavaScript rápida para comprobar que un determinado número de seguro social es válida.

function checkSSN() { 
    var inputSSN = #YourInput#, 
     ssnRegex = new RegExp("^(9[0-9][0-9]|666|000|078051120|219099999|123456789|123121234|321214321)|^([0-8][0-9][0-9]00)|^([0-8][0-9][0-9][0-9][0-9]000)$"), 
     repeats = /^(.)\1+$/; 

    //make sure we have 2 dashes in the input Social Security number 
    if(inputSSN.match(/./g).length === 2) { 
     //Once we have confirmed that there are the right number of dashes, remove them, and make sure that the resulting string is a number (you may or may not need this logic depending on the format of your input SSN. 
     inputSSN = inputSSN.replace(/-/g, ""); 

     if(!isNaN(inputSSN)) { 
      //Test the input SSN against our regex to ensure that it doesn't contain any disqualifying combinations. 
      if(!ssnRegex.test(inputSSN)) { 
       //Make sure the input SSN isn't just a repeated number 
       if(!repeats.test(inputSSN)) { 
        //If it lands inside of this, we know it's a valid option for a social security number. 
       } 
     } 
    } 
} 

Para la lógica ssnRegex:

La primera sección se ocupa de si el SSN comienza con un número 900-999, 666, 000, o uno de los SSN descalificantes conocidos mencionados anteriormente.

^(9 [0-9] [0-9] | 666 | 000 | 078 051 120 | 219099999 | 123456789 | 123121234 | 321214321)

la segunda sección se asegura de que la parte de 2 dígitos no es 00

^([0-8] [0-9] [0-9] 00)

la tercera sección se asegura de que la última porción no es 0000

^([ 0-8] [0-9] [0-9] [0-9] [ 0-9] 0000)

Además, verificamos que hayan ingresado un número y que no están utilizando un número repetido.