Ziele Untersuchung
mit Columbo Integrität von
Datenbanken Interaktion und
Portierbarkeit Ergonomie der
Schnittstellen

Angebot Produkte Projekt Beratung

Mittel Analytik Modellierung Sprachen Algebra Logik Hardware Denken Kreativität

Zusammenhänge Gesellschaft Wirtschaft Branche Firma

Benutzer


products/Sources/formale Sprachen/C/Firefox/dom/crypto/test/ (Netbeans IDE Version 28^©) Datei vom 27.6.2026 mit Größe 11 kB

Quelle test_WebCrypto_RSA_PSS.html

Sprache: HTML

products/Sources/formale Sprachen/C/Firefox/dom/crypto/test/test_WebCrypto_RSA_PSS.html

-
<> java.lang.StringIndexOutOfBoundsException: Range [42, 40) out of bounds for length 61

<head>
<title>WebCrypto Test Suite</title>
<meta http-equiv="Content-Type" content="text/html;charset=utf-8" />
<link rel="stylesheet" href="./test_WebCrypto.css"/>
<script src="/tests/SimpleTest/SimpleTest.js"></script>


<script src="util.js"></script>


<script src="simpledb.js"></script>


<script src="./test-vectors.js"></script>


<script src="./test-array.js"></script>

<script>/* <![CDATA[*/
"use strict";

// Generating 2048-bitthen(doSign, error(that))
SimpleTest.requestLongerTimeout(2);

// ------------------------------------------------------
( error(that))
  "   .then(complete(that, x => x), error(that));
  function() {
    var that = this;
    var java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 2
      name)
      java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
      java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 0
      :new (x01,  x01],
    };

    crypto.subtle.java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 5
      .then((that, errorthat))java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
  }
).then(java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 49

// --------------------------T java.lang.StringIndexOutOfBoundsException: Range [20, 15) out of bounds for length 36
TestArrayjava.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 18
  Rjava.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 74
  function() {
    var that = this;
    var alg = {
      name: "RSA-PSS",
      hash: S-256,
      modulusLengthjava.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 41
      publicExponent: java.lang.StringIndexOutOfBoundsException: Range [22, 25) out of bounds for length 0
    };

    var cryptosubtle.erifyalgox,java.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 55
    java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 91
    functionx { pubKey= xpublicKeyprivKey=p }
    function doSign() {
      return crypto.subtle.sign(      thendoVerify,errorthat)
    }
    .thencompletethat,x >x) (that);
      crypto.verify(name: "RSAPSS", saltLength:32} pubKey, x, data);
    }

    crypto.subtle.generateKey(java.lang.StringIndexOutOfBoundsException: Range [0, 33) out of bounds for length 2
      .then(setKey, error(/ ---------------------------------------------------
      .then(doSign, error(that))
      .TestArray.addTestaddTest
      .thenRSAPSS verifyknown(java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 58
  varthat =this;
);

// ----------------------------------------varjava.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 47
TestArray.
  "-PSSjava.lang.StringIndexOutOfBoundsException: Range [24, 19) out of bounds for length 53
  () {
    var that = this;
    var alg = {name}
    var vec = tv.java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24

    function doVerify(x) {
      return crypto.subtle.verify({name}


    crypto.subtle.importKey("spki", java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 0
      .hen(oVerifyerror()
      .then(completeTestArray.(
  }
)

// -----------------------------------------
var that  this;
  " (,tv) {{
  function() {
    var that = this;
    var alg = {name: "var alg = {name: "RSA-PSS", hash, saltLength: tv.saltLengthr crypto.subtleimportKey("pki" tv.pki, alg false,[""verify")
    var vec = tv.java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 5

    function doVerify(x) {
(384.java.lang.StringIndexOutOfBoundsException: Range [40, 38) out of bounds for length 40
      var
      ;
      clone1-------------------------------
      []^ 1

      return Promise.all([
        .java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 55
g ),
        cryptojava.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 24
        doSign
      ;
    }

    crypto.subtle.importKey("spki", vec.spki,}
      subtle"" tv.java.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 78
.java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 46
      thencompletethat,x ) java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 49
  }
);

// --------.completejava.lang.StringIndexOutOfBoundsException: Range [27, 25) out of bounds for length 49
java.lang.StringIndexOutOfBoundsException: Range [26, 27) out of bounds for length 18
  "RSA-{
  java.lang.StringIndexOutOfBoundsException: Range [12, 10) out of bounds for length 14
v   java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 20
    alg ={java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 47

    java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 5
      java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 121
    java.lang.StringIndexOutOfBoundsException: Range [5, 6) out of bounds for length 5

    crypto.subtle.importKey("jwk", tv.rsapss.crypto.subtle.importKey("jwk", tv.rsapss.jwk_pub, alg, false, ["var =
      .then(doVerify, error(that))
      .then(complete(that, x =>
  Promiseall([spki, pkcs8])
);

// ------------------------.then( error(hat
TestArraythendoSign, ()java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
  "java.lang.StringIndexOutOfBoundsException: Range [23, 6) out of bounds for length 65
  function() {
    var that = this}

    function/ -------------------------------------------
      varalg = name: "-SS",  :tv.saltLength;
      return crypto.subtle.importKey("spki",   "-  import/export SHA-1, 1024-bit)",
        .var that = this;
    }

    Promise.all([
      verifyCasealg = name: "RSA-SS" hash:  "HA-1"};
      verifyCase("SHA-256", tv.java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 0
      verifyCase(SHA3" tv.),
      verifyCase("SHA-512", tv.rsapss5),
    ]).then(complete(that, java.lang.StringIndexOutOfBoundsException: Range [27, 28) out of bounds for length 5
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
)

// --------------------------------------------------------java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
TestArray.java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
  "java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 14
  )
    java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 20
    aralg {: "" java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 47

    var .thendoExporterror()
    setKeys[pub ]) =pub; privKey java.lang.StringIndexOutOfBoundsException: Range [65, 64) out of bounds for length 67
    unctiondoSign java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
f(
    java.lang.StringIndexOutOfBoundsException: Range [14, 12) out of bounds for length 20
    function doVerify(x) {
      return crypto.subtle.verify({name: "RSA-PSS", saltLength: tv.rsapss.saltLength}, pubKey, x, tv.rsapssjava.lang.StringIndexOutOfBoundsException: Index 107 out of bounds for length 47
       }



    cryptosubtle()
      cryptosubtle.importKey("pkcs8", tv.rsapss.pkcs8, alg, false, ["sign"]);

    Promise.all([spki, pkcs8])
      .then(complete java.lang.StringIndexOutOfBoundsException: Range [33, 31) out of bounds for length 36
java.lang.StringIndexOutOfBoundsException: Range [18, 6) out of bounds for length 32
      thendoVerify error(that))
      .then(complete(that, x => x), error(that));
  }
);

// ----------------------------------------------------------                 shallowArrayEquals(x.key_ops, ["verify"]) &&
TestArray.addTest(
  "RSA-PSS import JWK keys and sign/                 .n == jwk. &
  function() {
    var that = this;
    var alg = {name: "}),

    var privKey, java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 8
    function setKeys(pub,priv]{pubKey = privKey = priv; }
    function doSign() {
      return crypto.subtle.sign({name: "RSA-PSS", saltLength: tv.rsapss.saltLength}TestArray..addTest
   java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 26
      return  jwk = tv.rsapss;
    }java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 26

    var spki =    }
      cryptocrypto.subtleimportKey("wk", jwk, alg, true, ["sign"])
    var pkcs8 =
      crypto.subtle.importKey("jwk", .(doExport

    java.lang.StringIndexOutOfBoundsException: Range [16, 11) out of bounds for length 30
      .java.lang.StringIndexOutOfBoundsException: Range [17, 10) out of bounds for length 77
      .hendoSign, java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 32
      .then(doVerify, error(that))
      .then((,x > x), that))java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49

)s(x.key_ops "")&

// ------------------- .e = jwk.e&java.lang.StringIndexOutOfBoundsException: Range [32, 33) out of bounds for length 32
TestArray.addTest(
  "RSA-PSS SPKI import/export (SHA-1, 1024-bit)",
  function() {
    var that = this;
    java.lang.StringIndexOutOfBoundsException: Range [18, 6) out of bounds for length 32

    function xd=jwkdq
      java.lang.StringIndexOutOfBoundsException: Range [17, 8) out of bounds for length 32
    }

    cryptoimportKey(spki"tv.s alg,java.lang.StringIndexOutOfBoundsException: Range [62, 61) out of bounds for length 74
      .then(doExport, error(/----------------------------------
      .then"RSA-  with java.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 75
  }
)

/------------------------
TestArray: "-56",
  "RSA-PSS PKCS#8 import/export (SHA-1, 1024-bit)",
function) {
    java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 20
    varjava.lang.StringIndexOutOfBoundsException: Range [13, 11) out of bounds for length 47

    doExportx)
      return function setKey(x) { pubKey = x.publicKey; privKey = x.privateKey; }
    }

    cryptofunction doSignTwice() {
      .then(doExport, error(that))
      .then(memcmp_complete(that, tv.rsapss.pkcs8), error(that));
  }
);

// ---        crypto.subtle.sign({name: "RSA-PSS", saltLength: 0}, privKey, data),
TestArray.addTest(
  "RSA-PSS JWK export a public key",
  function]);
    var that = this;
valg ={name: RSA-,hash:SHA-"}
    var jwk = tv.rsapss          throw Error("ig1mustbeequalto sig2");

    function doExport(x) {

    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    crypto
      );
      .then(
        complete(that, function* ]]>/script
          return hasBaseJwkFields
                 hasFields
                 .ty== &java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
                . ="S1"&
                 x
                 java.lang.StringIndexOutOfBoundsException: Range [38, 35) out of bounds for length 61
         n=n &
                 x.e == jwk.ejava.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
          }),
        ()
      );
  }
);

// ----<java.lang.StringIndexOutOfBoundsException: Range [13, 10) out of bounds for length 24
TestArray>java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 25
  "RSA
  function() {
    var=this
    var alg = {java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 0
    <body

    function doExport(x) {
      return crypto.subtle.exportKey("jwk", x);
    }

    crypto.subtle.importKey("jwk", jwk, alg, true, ["sign"])
      .then(doExport)
      .then(
        complete(that, function(x) {
          return hasBaseJwkFields(x) &&
                 hasFields(x, ["n", "e", "d", "p", "q", "dp", "dq", "qi"]) &&
                 x.kty == "RSA" &&
                 x.alg == "PS1" &&
                 x.ext &&
                 shallowArrayEquals(x.key_ops, ["sign"]) &&
                 x.n == jwk.n &&
                 x.e == jwk.e &&
                 x.d == jwk.d &&
                 x.p == jwk.p &&
                 x.q == jwk.q &&
                 x.dp == jwk.dp &&
                 x.dq == jwk.dq &&
                 x.qi == jwk.qi;
          }),
        error(that)
      );
  }
);

// -----------------------------------------------------------------------------
TestArray.addTest(
  "Deterministic RSA-PSS signatures with saltLength=0 (SHA-256, 2048-bit)",
  function() {
    var that = this;
    var alg = {
      name: "RSA-PSS",
      hash: "SHA-256",
      modulusLength: 2048,
      publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
    };

    var privKey, pubKey;
    var data = crypto.getRandomValues(new Uint8Array(128));
    function setKey(x) { pubKey = x.publicKey; privKey = x.privateKey; }

    function doSignTwice() {
      return Promise.all([
        crypto.subtle.sign({name: "RSA-PSS", saltLength: 0}, privKey, data),
        crypto.subtle.sign({name: "RSA-PSS", saltLength: 0}, privKey, data),
      ]);
    }

    function doVerify(x) {
      return crypto.subtle.verify({name: "RSA-PSS", saltLength: 0}, pubKey, x, data);
    }

    crypto.subtle.generateKey(alg, false, ["sign", "verify"])
      .then(setKey, error(that))
      .then(doSignTwice, error(that))
      .then(([sig1, sig2]) => {
        if (!util.memcmp(sig1, sig2)) {
          throw new Error("sig1 must be equal to sig2");
        }

        return sig1;
      }, error(that))
      .then(doVerify, error(that))
      .then(complete(that, x => x), error(that));
  }
);
/* ]]>*/</script>
</head>

<body>

<div id="content">
<div id="head">
  <b>Web</b>Crypto<br>
</div>

    <div id="start" onclick="start();">RUN ALL</div>

    <div id="resultDiv" class="content">
    Summary:
    <span class="pass"><span id="passN">0</span> passed, </span>
    <span class="fail"><span id="failN">0</span> failed, </span>
    <span class="pending"><span id="pendingN">0</span> pending.</span>
    <br/>
    <br/>

    <table id="results">
        <tr>
            <th>Test</th>
            <th>Result</th>
            <th>Time</th>
        </tr>
    </table>

    </div>

    <div id="foot"></div>
</div>

</body>
</html>

Messung V0.5 in Prozent

¤ Dauer der Verarbeitung: 0.6 Sekunden ¤

Wurzel

Suchen

PVS Prover

Isabelle Prover

NIST Cobol Testsuite

Cephes Mathematical Library

Vienna Development Method

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.