Skip to content
← Todas las publicaciones
· Delta1 Labs LicensingKeyright

Las cadenas de delegación permiten a los revendedores emitir sus propias claves

Firmas un contrato de distribución y la primera pregunta de integración es "¿cómo emiten nuestros distribuidores claves a los clientes finales?". Las dos respuestas obvias son erróneas: entregar a cada distribuidor tu clave raíz de firma y un solo portátil robado falsifica todo tu catálogo, o enrutar cada venta de distribuidor a través de una llamada en vivo a tu servicio de emisión y tus socios no pueden vender cuando tú estás caído. El diseño que aguanta es una cadena de delegación: entrega a cada distribuidor un certificado firmado que lleva su propia clave pública y un alcance que nunca puede exceder, deja que firme licencias de cliente final con la mitad privada, y haz que el cliente verifique toda la cadena sin conexión contra una única clave raíz fijada. Este artículo construye esa cadena en Keyright: el certificado de delegación y su alcance, cómo un distribuidor emite dentro de él, la verificación del SDK que recorre licencia a delegado a raíz, la regla de que el alcance solo puede estrecharse, y por qué revocar un certificado caduca en silencio cada clave que un distribuidor comprometido haya emitido jamás.

Acabas de firmar tu primer acuerdo de distribución. Un distribuidor en otra región venderá tu producto .NET, atenderá a sus propios clientes, emitirá sus propias claves de licencia y te remitirá una parte. El contrato está hecho; la pregunta de integración llega a la mañana siguiente: ¿cómo acuña realmente las claves nuestra gente?

Hay dos respuestas que parecen obvias y ambas son trampas.

La primera es entregar al distribuidor tu clave raíz de firma para que pueda emitir lo que necesite. Ahora cada portátil de socio guarda la clave que valida toda tu línea de productos, y el día en que uno de ellos sea víctima de phishing, robado o simplemente copiado a una máquina personal, el atacante puede acuñar una clave perpetua con todas las funciones para cualquier producto que vendas — y no puedes distinguir sus falsificaciones de tus propias firmas, porque son tu firma.

La segunda es enrutar cada venta de distribuidor de vuelta a través de tu servicio de emisión: el distribuidor rellena un formulario, tu servicio firma la clave, él la entrega. Nada se filtra, pero has hecho que el mostrador de ventas de tus socios dependa de tu disponibilidad y de tu ruta de red, y un distribuidor que no puede alcanzarte no puede cerrar una venta.

El diseño que no renuncia a ninguna de las dos cosas es una cadena de delegación. Este artículo construye una en Keyright.

Qué es una cadena de delegación

Toma prestada la forma de cómo funcionan los certificados TLS. Una clave raíz que mantienes sin conexión firma un pequeño número de certificados intermedios; esos intermedios firman los certificados de hoja que los servidores presentan realmente; y un navegador confía en una hoja porque puede recorrer la cadena de vuelta hasta una raíz que fija. La raíz privada casi nunca tiene que salir.

Trasplantado a las licencias, tres claves se alinean en fila:

  • Tu par de claves raíz vive en tu instancia de Keyright y no firma nada de cara al cliente. Firma certificados de delegación y nada más.
  • Cada distribuidor posee un par de claves de delegado. Lo generan ellos; conservan la mitad privada; tú nunca la ves. Tú firmas un certificado que vincula su mitad pública a un alcance.
  • El distribuidor firma licencias de cliente final con su clave privada de delegado.

Una licencia emitida de este modo no es un token suelto. Es un paquete: la licencia final, más el certificado de delegación que la autoriza, viajando juntos para que el cliente pueda verificar toda la cadena sin nada más que la única clave pública raíz que ya incluye.

Acuñar un certificado de delegación

El distribuidor genera un par de claves en su lado y te envía solo la mitad pública. Tú acuñas su certificado con la CLI de administración contra tu instancia, estampándolo con el alcance dentro del cual tiene permitido vender:

keyright delegate create \
  --name        "Northwind Distribution GmbH" \
  --public-key  "MCowBQYDK2VwAyEA9r...kQ=" \
  --product     acme-suite \
  --max-expiry  2027-12-31 \
  --allow-entitlement export,max-dpi,seats \
  --max-seats   50 \
  --not-after   2026-12-31

Lee el alcance con atención, porque cada campo es un techo que el distribuidor nunca puede elevar:

  • --product lo fija a una línea de producto. Un delegado para acme-suite no puede firmar una clave para acme-enterprise.
  • --max-expiry es la expiración más lejana que puede llevar cualquier licencia que emita. Puede vender una clave de un año; no puede vender una perpetua.
  • --allow-entitlement es el conjunto de nombres de atributos que puede conceder. Cualquier cosa fuera de él se descarta en la verificación, de modo que un distribuidor no puede habilitar en silencio una función que reservas para la venta directa.
  • --max-seats limita el número de asientos en cualquier clave individual que emita.
  • --not-after es la expiración del propio certificado — la delegación en sí caduca en esta fecha, con independencia de las claves emitidas bajo ella, de modo que un contrato de socio vencido deja de acuñar claves automáticamente.

El servicio devuelve el certificado firmado. La firma cubre la clave pública del delegado y el alcance juntos, así que ninguno puede alterarse sin romperla:

HTTP/1.1 201 Created
Content-Type: application/json

{
  "delegateId": "del_7Qk2",
  "name": "Northwind Distribution GmbH",
  "publicKey": "MCowBQYDK2VwAyEA9r...kQ=",
  "scope": {
    "product": "acme-suite",
    "maxExpiry": "2027-12-31T00:00:00Z",
    "allowEntitlements": ["export", "max-dpi", "seats"],
    "maxSeats": 50
  },
  "notAfter": "2026-12-31T00:00:00Z",
  "signedBy": "root",
  "certificate": "eyJ2IjoxLCJkZWxlZ2F0ZUlkIjoiZGVsXzdRazIi...<signed>"
}

Esa cadena certificate es lo que el distribuidor incrusta en cada licencia que emite. Tú no guardas nada secreto suyo; él no guarda nada secreto tuyo.

Delegation chain: root signs the delegate, the delegate signs the keyRoot keypairon your instancesigns delegatecerts onlyDelegate certificatereseller public keyproduct: acme-suitemaxExpiry: 2027-12-31allow: export, seatsmaxSeats: 50signedBy: rootEnd-customer licenselicensee: acct_8f21expiry: 2027-03-01export=true, seats=10signedBy: del_7Qk2+ delegate cert(bundled)signssignsWhat the client does with only the pinned root public key1. verify the end license against the delegate public key in the bundle2. verify the delegate certificate against the pinned root public key3. clamp the license to the scope — expiry, entitlements and seats may only narrowThe root private key never signs a customer key, so it never has to leave the instance.

El distribuidor emite dentro del alcance

El distribuidor ejecuta su propio pequeño paso de emisión — una CLI en su mostrador de ventas, o un servicio ligero propio — firmando con la clave privada de delegado. Nunca llama a tu instancia para cerrar una venta:

keyright issue \
  --delegate-cert   ./northwind.cert \
  --delegate-key    ./northwind.key \
  --licensee        acct_8f21 \
  --expiry          2027-03-01 \
  --entitlement     export=true \
  --entitlement     seats=10

La salida es el paquete — licencia final y certificado de delegación concatenados en un único blob .lic que el cliente activa exactamente como cualquier otra clave. Si el distribuidor intenta excederse — --expiry 2030-01-01, más allá de su maxExpiry, o --entitlement watermark=false, que no está en su conjunto permitido — el emisor sensato lo rechaza localmente. Pero el rechazo local es una comodidad, no la garantía. La garantía vive en el cliente, que vuelve a comprobarlo todo sin importar lo que la herramienta del distribuidor permitiera o no.

El cliente verifica la cadena

En la máquina del cliente, el SDK está configurado con una sola cosa que importa: la clave pública raíz. No la del distribuidor — la de la raíz. Esa única fijación es lo que permite al cliente confiar en una clave firmada por un socio del que nunca ha oído hablar.

static readonly KeyrightClient License = KeyrightClient.Initialize(new KeyrightOptions
{
    Product             = "acme-suite",
    RootPublicKeyBase64 = AcmeKeys.RootPublicKey,   // the ROOT, pinned in the app
    ServiceUrl          = "https://licensing.acme.example",
});

LicenseInfo info = License.Validate();

Validate() recorre la cadena dentro del paquete:

  1. Lee el certificado de delegación y verifica la firma de la licencia final contra la clave pública de delegado que lleva el certificado.
  2. Verifica la firma del certificado de delegación contra la clave pública raíz fijada — y rechaza si el notAfter del certificado ya ha pasado.
  3. Luego ciñe la licencia al alcance del certificado antes de reportar nada: la expiración efectiva es la más temprana entre la expiración de la licencia y el maxExpiry del delegado; cualquier atributo que no esté en allowEntitlements se trata como no establecido; el número de asientos se limita a maxSeats.

Solo una licencia firmada por un delegado, cuyo delegado está firmado por tu raíz, y que se sitúa por completo dentro de su alcance, vuelve como válida. A partir de ahí tu aplicación aplica la verificación exactamente como siempre lo ha hecho — info.IsValid, y luego los atributos:

if (!info.IsValid) { RunEvaluation(info); return; }

if (License.IsEnabled("export")) EnableExport();
int seats = (int)License.GetLimit("seats", fallback: 1);

// Who issued it — useful for support and telemetry, never for the gate itself.
Log.Information("Licensed via {Delegate}", info.IssuedBy);   // "del_7Qk2"

El cliente nunca sabe ni le importa que un distribuidor firmara su clave. La cadena es un detalle de implementación de la confianza; la puerta con la que se topa es la misma que la de un cliente directo.

El alcance solo puede estrecharse

Esta es la propiedad que hace segura la delegación, y vale la pena decirlo con claridad: nada en la parte baja de la cadena puede conceder más que lo que su padre permitió. El ceñido del paso 3 no es un consejo — es todo el modelo de seguridad. Un distribuidor que edite su emisor para estampar maxExpiry: 2099 sobre una clave no gana nada, porque el cliente toma el mínimo entre la expiración de la licencia y el maxExpiry del alcance, y el alcance está dentro del certificado, y el certificado está firmado por tu raíz. Un solo byte cambiado en el alcance rompe la firma de la raíz y la cadena falla en cerrado en el paso 2.

Así que lo peor que puede hacer una clave de distribuidor totalmente comprometida es emitir claves dentro del alcance que ya le concediste — un producto, expiración acotada, un conjunto de atributos fijo, un techo de asientos. Eso es un mal día. No es una catástrofe, y no se puede falsificar hacia tus otros productos. Compáralo con la primera trampa, donde una clave raíz filtrada es la catástrofe, y punto.

Revocación que se propaga

Como cada licencia final en el campo lleva el certificado del que desciende, tienes un interruptor de apagado a nivel de certificado. Si la clave de un distribuidor se ve comprometida — o el contrato termina, o lo pillan sobreemitiendo — revocas el delegado, una sola entrada, y cada licencia que ese distribuidor haya firmado deja de validar en su siguiente revalidación de ventana de gracia:

keyright delegate revoke del_7Qk2 --reason "partner contract ended"

El cliente se entera de que el delegado está revocado del mismo modo en que se entera de que una clave individual lo está — a través de la lista de revocación que ya descarga — y falla la cadena en el eslabón del delegado. No tienes que saber a qué clientes finales vendió ese distribuidor, ni perseguir claves individuales; cortar la rama tira cada hoja que haya en ella. Para un cierre limpio de socio, normalmente también dejarías que notAfter caduque en lugar de revocar en duro, de modo que los clientes existentes agoten sus plazos mientras no se pueden acuñar claves nuevas.

Probar la cadena

La prueba que se gana su lugar es la prueba de exceso — demostrar que el cliente se niega a honrar una violación del alcance incluso cuando la firma del distribuidor es perfectamente válida:

[Fact]
public void Client_clamps_a_license_that_exceeds_its_delegate_scope()
{
    var root     = TestRoot.Create();
    var delegate_ = root.MintDelegate(product: "acme-suite",
                       maxExpiry: new DateTime(2027, 12, 31), maxSeats: 50,
                       allow: new[] { "export", "seats" });

    // A validly-signed key that asks for more than the scope allows.
    string bundle = delegate_.Issue(licensee: "acct_8f21",
                       expiry: new DateTime(2099, 1, 1),   // past maxExpiry
                       entitlements: new() { ["seats"] = 500 });  // past maxSeats

    var client = KeyrightClient.Initialize(new KeyrightOptions
        { Product = "acme-suite", RootPublicKeyBase64 = root.PublicKeyBase64,
          LicenseBlob = bundle });

    var info = client.Validate();

    Assert.True(info.IsValid);                                  // chain is well-formed
    Assert.True(info.Expiry <= new DateTime(2027, 12, 31));     // expiry clamped to scope
    Assert.Equal(50, client.GetLimit("seats", fallback: 1));    // seats clamped to scope
}

Combínala con la inversa — una clave dentro del alcance valida y conserva sus propios números, más pequeños — y una tercera que revoque el delegado y afirme que la cadena entonces falla en cerrado. Un servicio de emisión falso en memoria te permite acuñar raíces, delegados y hojas de prueba sin tocar tu instancia real.

La conclusión

Los distribuidores necesitan acuñar claves; tú necesitas no repartir jamás tu clave raíz y no hacer que tus socios dependan de tu disponibilidad para vender. Una cadena de delegación te da ambas cosas. Firma a cada distribuidor un certificado que vincule su clave pública a un alcance que sea un techo duro — un producto, una expiración máxima, un conjunto de atributos permitido, un tope de asientos y una expiración sobre la propia delegación. Deja que firmen claves de cliente final sin conexión con la mitad privada. Incluye solo la clave pública raíz en tu aplicación, y deja que el SDK recorra licencia → delegado → raíz y ciña cada clave a su alcance antes de reportarla como válida. El alcance solo puede estrecharse, así que un socio comprometido está acotado, no es catastrófico; y como cada clave lleva su certificado padre, revocar un delegado retira cada clave bajo él sin que jamás conozcas la lista de clientes. Así es como dejas que cien distribuidores emitan claves y aún conservas exactamente una clave que importa.

Prueba Nebula.NET

Endurece tu código .NET en minutos — empieza con la edición gratuita.