7ojo/perl6-platform:4: - LDAP_ADMIN_PASSWORD="aiquoD1F"
7ojo/perl6-platform:32: userPassword: {crypt}x
7ojo/perl6-platform:55: @cmd.push: '-D' if not %params<password>;
7ojo/perl6-platform:63: @cmd.push: '--disabled-password' if not %params<password>;
Altai-man/perl6-Config-Netrc:24: password => {value => val, comment => my-comment}
Altai-man/perl6-Config-Netrc:26: Of course, login or password lines are optional and comment entry for lines like following:
Altai-man/perl6-Config-Netrc:16: <password>? \n? }
Altai-man/perl6-Config-Netrc:20: token password { \h*? 'password' \h+? (\w+) (<comment>?) <eol> }
Altai-man/perl6-Config-Netrc:27: password => $<password>.made}
Altai-man/perl6-Config-Netrc:31: password => $<password>.made}
Altai-man/perl6-Config-Netrc:62: method password ($/) { $/.make: comment-layering($/); }
Altai-man/perl6-Config-Netrc:94: # password p
Altai-man/perl6-Config-Netrc:98: # password default_password
Altai-man/perl6-Config-Netrc:103: # password => {value => p}}
Altai-man/perl6-Config-Netrc:107: # password => {value => default_password}}]}
Altai-man/perl6-Config-Netrc:28: if $entry<password> {
Altai-man/perl6-Config-Netrc:29: $output ~= " password " ~
Altai-man/perl6-Config-Netrc:30: $entry<password><value> ~ ' ' ~
Altai-man/perl6-Config-Netrc:31: ($entry<password><comment>.defined ??
Altai-man/perl6-Config-Netrc:32: $entry<password><comment>
Altai-man/perl6-Config-Netrc:12: password p # cool password
Altai-man/perl6-Config-Netrc:16: password default_password
Altai-man/perl6-Config-Netrc:25: password pd
Altai-man/perl6-Config-Netrc:41: password p # easy case
Altai-man/perl6-Config-Netrc:48: password p # with only password
CIAvash/App-Football:340: source code form), and must require no special password or key for
CIAvash/WebService-FootballData:340: source code form), and must require no special password or key for
Cofyc/perl6-redis:217: method auth(Str $password) returns Bool {
Cofyc/perl6-redis:218: return self.exec_command("AUTH", $password);
Cofyc/perl6-redis:12: #dies-ok { $r.auth("WRONG PASSWORD"); }
CurtTilmes/perl6-libcurl:25: proxies, cookies, user+password authentication (Basic, Digest,
CurtTilmes/perl6-libcurl:210: [password](https://curl.haxx.se/libcurl/c/CURLOPT_PASSWORD.html)
CurtTilmes/perl6-libcurl:459: embedded user + password.
CurtTilmes/perl6-libcurl:197: password => (CURLOPT_PASSWORD, CURLOPT_STR ),
CurtTilmes/perl6-libcurl:409: constant CURLOPT_PASSWORD = CURLOPTTYPE_OBJECTPOINT + 174;
CurtTilmes/perl6-libcurl:411: constant CURLOPT_PROXYPASSWORD = CURLOPTTYPE_OBJECTPOINT + 176;
CurtTilmes/perl6-libcurl:440: constant CURLOPT_TLSAUTH_PASSWORD = CURLOPTTYPE_OBJECTPOINT + 205;
CurtTilmes/perl6-libcurl:21: is $curl.statusline, 'HTTP/1.1 401 You give me wrong password',
CurtTilmes/perl6-libcurl:24: is $curl.content, "Wrong password dude. Get it fixed and return.\n", 'content';
Emeric54/p6-text-caesar:13: "tags" : [ "crypt", "password" ],
JJ/p6-math-constants:340: source code form), and must require no special password or key for
Juerd/p6-mqtt:250: No username and password are sent to the server.
LLFourn/p6-AttrX-InitArg:13: method get-message($password){
LLFourn/p6-AttrX-InitArg:14: $password eq 'opensesame' ?? $!message !! Nil;
LLFourn/p6-AttrX-InitArg:10: method get-secret-message($password){
LLFourn/p6-AttrX-InitArg:11: $password eq 'opensesame' ?? $!message !! Str;
LLFourn/p6-AttrX-InitArg:11: method get-message($password){
LLFourn/p6-AttrX-InitArg:12: $password eq 'opensesame' ?? $!message !! Nil;
LLFourn/p6-AttrX-InitArg:8: method get-secret-message($password){
LLFourn/p6-AttrX-InitArg:9: $password eq 'opensesame' ?? $!message !! Str;
MARTIMM/Auth-SCRAM:46: :password<pencil>,
MARTIMM/Auth-SCRAM:40: * mangle-password and clean-up in user objects are made optional. Called when defined.
MARTIMM/Auth-SCRAM:7: * Keep information when calculated. User request boolean and username/password/authzid tuple must be kept the same. This saves time.
MARTIMM/Auth-SCRAM:15: # and username/password/authzid must be kept the same. This saves time.
MARTIMM/Auth-SCRAM:30: Str :$password,
MARTIMM/Auth-SCRAM:45: die 'No username and/or password provided'
MARTIMM/Auth-SCRAM:46: unless ? $username and ? $password;
MARTIMM/Auth-SCRAM:54: self.init( :$username, :$password, :$authzid, :client-object($helper-object));
MARTIMM/Auth-SCRAM:75: Str :$password!,
MARTIMM/Auth-SCRAM:95: :$username, :$password, :$authzid, :$client-object
MARTIMM/Auth-SCRAM:124: Str:D :$username is copy, Str:D :$password is copy,
MARTIMM/Auth-SCRAM:133: $password = self.normalize( $password, :!prep-username, :$enforce);
MARTIMM/Auth-SCRAM:137: my Buf $mangled-password;
MARTIMM/Auth-SCRAM:138: if $helper-object.^can('mangle-password') {
MARTIMM/Auth-SCRAM:139: $mangled-password = $helper-object.mangle-password(
MARTIMM/Auth-SCRAM:140: :$username, :$password, :$authzid
MARTIMM/Auth-SCRAM:145: $mangled-password = Buf.new($password.encode);
MARTIMM/Auth-SCRAM:148: $!pbkdf2.derive( $mangled-password, $salt, $iter);
MARTIMM/Auth-SCRAM:152: method client-key ( Buf $salted-password --> Buf ) {
MARTIMM/Auth-SCRAM:154: hmac( $salted-password, 'Client Key', &$!CGH);
MARTIMM/Auth-SCRAM:170: method server-key ( Buf $salted-password --> Buf ) {
MARTIMM/Auth-SCRAM:172: hmac( $salted-password, 'Server Key', &$!CGH);
MARTIMM/Auth-SCRAM:222: # Normalize password
MARTIMM/Auth-SCRAM:226: die "Password not accepted" if $prepped-text ~~ Bool;
MARTIMM/Auth-SCRAM:28: Str :$password!,
MARTIMM/Auth-SCRAM:43: Usernames and password (and maybe the authorization id) must be normalized.
MARTIMM/Auth-SCRAM:49: set to True. There is only one type of profile for passwords so no control
MARTIMM/Auth-SCRAM:63: Username, password and authorization id are not needed when a server side object
MARTIMM/Auth-SCRAM:82: Str:D :$username is copy, Str:D :$password is copy,
MARTIMM/Auth-SCRAM:89: Calculate the derived key from the password, salt and number of iterations. The
MARTIMM/Auth-SCRAM:92: The username and password are normalized using the PRECIS framework described
MARTIMM/Auth-SCRAM:99: When the method C<mangle-password> is defined in the user provided helper
MARTIMM/Auth-SCRAM:103: method mangle-password (
MARTIMM/Auth-SCRAM:105: Str :$password,
MARTIMM/Auth-SCRAM:112: my Buf $mangled-password .= new($password.encode);
MARTIMM/Auth-SCRAM:117: method client-key ( Buf $salted-password --> Buf ) {
MARTIMM/Auth-SCRAM:159: username or password profile is choosen. C<$case-preserved-profile> selects
MARTIMM/Auth-SCRAM:10: # and username/password/authzid must be kept the same. This saves time.
MARTIMM/Auth-SCRAM:16: has Str $!password;
MARTIMM/Auth-SCRAM:41: has Buf $!salted-password;
MARTIMM/Auth-SCRAM:60: Str :$username, Str :$password, Str :$authzid,
MARTIMM/Auth-SCRAM:68: Str:D :$password!,
MARTIMM/Auth-SCRAM:74: $!password = $password;
MARTIMM/Auth-SCRAM:168: $!salted-password = self.derive-key(
MARTIMM/Auth-SCRAM:169: :$!username, :$!password, :$!authzid, :!enforce
MARTIMM/Auth-SCRAM:174: $!client-key = self.client-key($!salted-password);
MARTIMM/Auth-SCRAM:241: $!server-key = self.server-key($!salted-password);
MARTIMM/Auth-SCRAM:43: :password<pencil>,
MARTIMM/Auth-SCRAM:88: Str:D :$username!, Str:D :$password!, Str :$authzid,
MARTIMM/Auth-SCRAM:116: =item1 B<mangle-password>. This method is optional. Some servers, like mongod,
MARTIMM/Auth-SCRAM:117: need extra manipulations to mangle the data. The username and password are
MARTIMM/Auth-SCRAM:120: method mangle-password (
MARTIMM/Auth-SCRAM:121: Str :$username, Str :$password, Str :$authzid
MARTIMM/Auth-SCRAM:127: my Buf $mangled-password = Buf.new($password.encode);
MARTIMM/Auth-SCRAM:10: # and username/password/authzid must be kept the same. This saves time.
MARTIMM/Auth-SCRAM:16: has Str $!password;
MARTIMM/Auth-SCRAM:41: has Buf $!salted-password;
MARTIMM/Auth-SCRAM:82: Str :$username, Str :$password,
MARTIMM/Auth-SCRAM:89: my Buf $salted-password = self.derive-key(
MARTIMM/Auth-SCRAM:90: :$username, :$password, :enforce,
MARTIMM/Auth-SCRAM:95: my Buf $client-key = self.client-key($salted-password);
MARTIMM/Auth-SCRAM:97: my Buf $server-key = self.server-key($salted-password);
MARTIMM/Auth-SCRAM:16: risk that passwords are stolen. The server role helps to convert the username
MARTIMM/Auth-SCRAM:17: and password into a credential tupple which can be stored without the risk that
MARTIMM/Auth-SCRAM:18: the password can be retrieved from this data. Below is a simple implementation
MARTIMM/Auth-SCRAM:49: method add-user ( $username is copy, $password is copy ) {
MARTIMM/Auth-SCRAM:53: :$username, :$password, :$salt, :iter(4096), :server-object(self)
MARTIMM/Auth-SCRAM:117: # receive the password and password preferable over a secure connection
MARTIMM/Auth-SCRAM:119: my Str $password = '...'
MARTIMM/Auth-SCRAM:120: $crd.add-user( $user, $password);
MARTIMM/Auth-SCRAM:179: Str :$username, Str :$password,
MARTIMM/Auth-SCRAM:196: When the method C<mangle-password> is defined, that method will be called for
MARTIMM/Auth-SCRAM:23: Str :$username, Str:D :$password, Str :$authzid,
MARTIMM/Auth-SCRAM:31: my Buf $mangled-password;
MARTIMM/Auth-SCRAM:32: if $helper-object.^can('mangle-password') {
MARTIMM/Auth-SCRAM:33: $mangled-password = $helper-object.mangle-password(
MARTIMM/Auth-SCRAM:34: :$username, :$password, :$authzid
MARTIMM/Auth-SCRAM:39: $mangled-password = Buf.new($password.encode);
MARTIMM/Auth-SCRAM:42: $!pbkdf2.derive( $mangled-password, $salt, $iter);
MARTIMM/Auth-SCRAM:14: # and username/password/authzid must be kept the same. This saves time.
MARTIMM/Auth-SCRAM:20: has Str $!password;
MARTIMM/Auth-SCRAM:32: # Normalization of username and password can be skipped if normal
MARTIMM/Auth-SCRAM:56: has Buf $!salted-password;
MARTIMM/Auth-SCRAM:74: Str:D :$password!,
MARTIMM/Auth-SCRAM:83: $!password = $password;
MARTIMM/Auth-SCRAM:188: # $!password = self!saslPrep($!password);
MARTIMM/Auth-SCRAM:248: my Buf $mangled-password;
MARTIMM/Auth-SCRAM:249: if $!client-side.^can('mangle-password') {
MARTIMM/Auth-SCRAM:250: $mangled-password = $!client-side.mangle-password(
MARTIMM/Auth-SCRAM:251: :$!username, :$!password, :$!authzid
MARTIMM/Auth-SCRAM:256: $mangled-password = self.mangle-password($password);
MARTIMM/Auth-SCRAM:259: $!salted-password = $!pbkdf2.derive( $mangled-password, $!s-salt, $!s-iter);
MARTIMM/Auth-SCRAM:261: $!client-key = hmac( $!salted-password, 'Client Key', &$!CGH);
MARTIMM/Auth-SCRAM:332: $!server-key = hmac( $!salted-password, 'Server Key', &$!CGH);
MARTIMM/Auth-SCRAM:497: my Buf $mangled-password;
MARTIMM/Auth-SCRAM:498: if $!client-side.^can('mangle-password') {
MARTIMM/Auth-SCRAM:499: $mangled-password = $!client-side.mangle-password(
MARTIMM/Auth-SCRAM:500: :$!username, :$!password, :$!authzid
MARTIMM/Auth-SCRAM:505: $mangled-password = self.mangle-password($password);
MARTIMM/Auth-SCRAM:508: $!salted-password = $!pbkdf2.derive( $mangled-password, $!s-salt, $!s-iter);
MARTIMM/Auth-SCRAM:510: $!client-key = hmac( $!salted-password, 'Client Key', &$!CGH);
MARTIMM/Auth-SCRAM:541: method mangle-password ( Str:D $password --> Buf ) {
MARTIMM/Auth-SCRAM:543: Buf.new($!password.encode);
MARTIMM/Auth-SCRAM:41: # method mangle-password() is optional
MARTIMM/Auth-SCRAM:55: :password<pencil>,
MARTIMM/Auth-SCRAM:32: method add-user ( $username is copy, $password is copy ) {
MARTIMM/Auth-SCRAM:35: :$username, :$password,
MARTIMM/Auth-SCRAM:80: # method mangle-password() is optional
MARTIMM/Auth-SCRAM:30: method add-user ( $username is copy, $password is copy ) {
MARTIMM/Auth-SCRAM:33: :$username, :$password,
MARTIMM/Auth-SCRAM:84: # method mangle-password() is optional
MARTIMM/PKCS5:7: This package implements part of PKCS 5 which is, according to the [wikipedia](https://en.wikipedia.org/wiki/PKCS), a Password-based Encryption Standard. The derivation algorithm PBKDF2 is implemented as a class in this package.
MARTIMM/PKCS5:26: # Input: P password, an octet string
MARTIMM/PKCS5:47: Calculate the derived key given the password C<$pw> and a salt C<$salt>. It
MARTIMM/PKCS5:16: Buf.new('password'.encode),
MARTIMM/PKCS5:21: is $spw, '0c60c80f961f0e71f3a9b524af6012062fe037a6', "Test 'password' and 1 iteration";
MARTIMM/PKCS5:24: Buf.new('password'.encode),
MARTIMM/PKCS5:29: is $spw, 'ea6c014dc72d6f8ccd1ed92ace1d41f0d8de8957', "Test 'password' and 2 iterations";
MARTIMM/PKCS5:32: Buf.new('password'.encode),
MARTIMM/PKCS5:37: is $spw, '4b007901b765489abead49d926f721d065a429c1', "Test 'password' and 4096 iterations";
MARTIMM/PKCS5:42: Buf.new('password'.encode),
MARTIMM/PKCS5:47: is $spw, 'eefe3d61cd4da4e4e9945b3d6ba2158c2634e984', "Test 'password' and 16777216 iterations";
MARTIMM/PKCS5:55: Buf.new('passwordPASSWORDpassword'.encode),
MARTIMM/mongo-perl6-driver:176: * In the future, host/port arguments to Client must be replaced by using a URI in the format ```mongodb://[username:password@]host1[:port1]…
MARTIMM/mongo-perl6-driver:178: This is done now. The Client.instance method will only accept uri which will be processed by the Uri class. The default uri will be ```mongodb://``` …
MARTIMM/mongo-perl6-driver:42: * Added normalization for username and passwords using Unicode::Precis. At the moment the UsernameCasePreserved profile is used until there is some consensus about it.
MARTIMM/mongo-perl6-driver:44: Auth::SCRAM implemented. No username/password normalization yet.
MARTIMM/mongo-perl6-driver:53: * Refactored MongoDB::Users to MongoDB::HL::Users because it can all be done using the lower level run-command(). This adds some control and tests on password length and use of characters. Therefore this makes it a higher level implementation.
MARTIMM/mongo-perl6-driver:59: * URI handling of username/password. Used uri-unescape() from URI::Escape module on usernames and passwords. Not sure if needed on fqdn.
MARTIMM/mongo-perl6-driver:64: * Took a long time to implement authentication and had to write a pbkdf2 and scram sha1 implementations first. Then find out what exactly mongodb n…
MARTIMM/mongo-perl6-driver:96: run-command. This module adds facilities like checking password length etc.
MARTIMM/mongo-perl6-driver:12: has Str $.password;
MARTIMM/mongo-perl6-driver:21: Str :$username = '', Str :$password = '',
MARTIMM/mongo-perl6-driver:27: $!password = $password;
MARTIMM/mongo-perl6-driver:60: fatal-message("$e0 password must $e1") unless ? $!password;
MARTIMM/mongo-perl6-driver:70: fatal-message("$e0 password must not $e1") if ? $!password;
MARTIMM/mongo-perl6-driver:79: # password is optional
MARTIMM/mongo-perl6-driver:93: fatal-message("$e0 password must $e1") unless ? $!password;
MARTIMM/mongo-perl6-driver:102: fatal-message("$e0 password must $e1") unless ? $!password;
MARTIMM/mongo-perl6-driver:78: method mangle-password ( Str:D :$username, Str:D :$password --> Buf ) {
MARTIMM/mongo-perl6-driver:86: my TestValue $tv-pw = $upf-os.enforce($password);
MARTIMM/mongo-perl6-driver:87: fatal-message("Password not accepted") if $tv-un ~~ Bool;
MARTIMM/mongo-perl6-driver:88: info-message("Password accepted");
MARTIMM/mongo-perl6-driver:94: my utf8 $mdb-hashed-pw = ($username ~ ':mongo:' ~ $password).encode;
MARTIMM/mongo-perl6-driver:110: # password, servers, database and options.
MARTIMM/mongo-perl6-driver:115: my @item-list = <username password database options>;
MARTIMM/mongo-perl6-driver:137: $set( 'password', 'password');
MARTIMM/mongo-perl6-driver:102: mongodb://u1:pw1@nsa.us:666,my.datacenter.gov/nsa/?replicaSet=foryoureyesonly | User u1 with password pw1 logging in on database nsa on server nsa.us:666 and my.datacenter.gov:27017 which must both be member of a replica set named foryoureyesonly.
MARTIMM/mongo-perl6-driver:74: Str:D $user, Str:D $password,
MARTIMM/mongo-perl6-driver:89: # Check if password is too short
MARTIMM/mongo-perl6-driver:91: elsif $password.chars < $!min-pw-length {
MARTIMM/mongo-perl6-driver:93: "Password too short, must be >= $!min-pw-length",
MARTIMM/mongo-perl6-driver:94: oper-data => $password,
MARTIMM/mongo-perl6-driver:99: # Check if password answers to rule given by attribute code
MARTIMM/mongo-perl6-driver:105: $pw-ok = ($password ~~ m/ <[a..z]> /).Bool;
MARTIMM/mongo-perl6-driver:110: $password ~~ m/ <[a..z]> / and
MARTIMM/mongo-perl6-driver:111: $password ~~ m/ <[A..Z]> /
MARTIMM/mongo-perl6-driver:117: $password ~~ m/ <[a..z]> / and
MARTIMM/mongo-perl6-driver:118: $password ~~ m/ <[A..Z]> / and
MARTIMM/mongo-perl6-driver:119: $password ~~ m/ \d /
MARTIMM/mongo-perl6-driver:125: $password ~~ m/ <[a..z]> / and
MARTIMM/mongo-perl6-driver:126: $password ~~ m/ <[A..Z]> / and
MARTIMM/mongo-perl6-driver:127: $password ~~ m/ \d / and
MARTIMM/mongo-perl6-driver:128: $password ~~ m/ <[`~!@\#\$%^&*()\-_=+[{\]};:\'\"\\\|,<.>\/\?]> /
MARTIMM/mongo-perl6-driver:134: "Password does not have the right properties",
MARTIMM/mongo-perl6-driver:135: oper-data => $password,
MARTIMM/mongo-perl6-driver:142: # Normalize username and password
MARTIMM/mongo-perl6-driver:149: my TestValue $tv-pw = $upf-os.prepare($password);
MARTIMM/mongo-perl6-driver:150: fatal-message("Password not accepted") if $tv-un ~~ Bool;
MARTIMM/mongo-perl6-driver:151: info-message("Password accepted");
MARTIMM/mongo-perl6-driver:153: # Create user where digestPassword is set false
MARTIMM/mongo-perl6-driver:157: digestPassword => False
MARTIMM/mongo-perl6-driver:161: # Create user where digestPassword is set false
MARTIMM/mongo-perl6-driver:164: pwd => (Digest::MD5.md5_hex( [~] $user, ':mongo:', $password)),
MARTIMM/mongo-perl6-driver:165: digestPassword => False
MARTIMM/mongo-perl6-driver:177: Str:D $user, Str :$password,
MARTIMM/mongo-perl6-driver:185: digestPassword => True
MARTIMM/mongo-perl6-driver:188: if ?$password {
MARTIMM/mongo-perl6-driver:189: if $password.chars < $!min-pw-length {
MARTIMM/mongo-perl6-driver:191: "Password too short, must be >= $!min-pw-length",
MARTIMM/mongo-perl6-driver:192: oper-data => $password,
MARTIMM/mongo-perl6-driver:200: $pw-ok = ($password ~~ m/ <[a..z]> /).Bool;
MARTIMM/mongo-perl6-driver:205: $password ~~ m/ <[a..z]> / and
MARTIMM/mongo-perl6-driver:206: $password ~~ m/ <[A..Z]> /
MARTIMM/mongo-perl6-driver:212: $password ~~ m/ <[a..z]> / and
MARTIMM/mongo-perl6-driver:213: $password ~~ m/ <[A..Z]> / and
MARTIMM/mongo-perl6-driver:214: $password ~~ m/ \d /
MARTIMM/mongo-perl6-driver:220: $password ~~ m/ <[a..z]> / and
MARTIMM/mongo-perl6-driver:221: $password ~~ m/ <[A..Z]> / and
MARTIMM/mongo-perl6-driver:222: $password ~~ m/ \d / and
MARTIMM/mongo-perl6-driver:223: $password ~~ m/ <[`~!@\#\$%^&*()\-_=+[{\]};:\'\"\\\|,<.>\/\?]> /
MARTIMM/mongo-perl6-driver:232: # Normalize username and password
MARTIMM/mongo-perl6-driver:239: my TestValue $tv-pw = $upf-os.prepare($password);
MARTIMM/mongo-perl6-driver:240: fatal-message("Password not accepted") if $tv-un ~~ Bool;
MARTIMM/mongo-perl6-driver:241: info-message("Password accepted");
MARTIMM/mongo-perl6-driver:245: $req<pwd> = (Digest::MD5.md5_hex([~] $user, ':mongo:', $password));
MARTIMM/mongo-perl6-driver:250: "Password does not have the proper elements",
MARTIMM/mongo-perl6-driver:251: oper-data => $password,
MARTIMM/mongo-perl6-driver:39: :password('mt+++'),
MARTIMM/mongo-perl6-driver:68: Minimum password length.
MARTIMM/mongo-perl6-driver:75: Password checking attribute. See set-pw-security() below.
MARTIMM/mongo-perl6-driver:88: Method to specify checks upon usernames and passwords. Default values for
MARTIMM/mongo-perl6-driver:89: the username minimal length is 2. For passwords idem depending on the password
MARTIMM/mongo-perl6-driver:90: attribute code. $pw-attribs specifies how passwords are to be checked. There are
MARTIMM/mongo-perl6-driver:109: using a password of less the 4 characters the call is bound to fail.
MARTIMM/mongo-perl6-driver:115: Str:D $user, Str:D $password,
MARTIMM/mongo-perl6-driver:141: Str:D $user, Str :$password,
MARTIMM/mongo-perl6-driver:27: # database, username, password and options
MARTIMM/mongo-perl6-driver:258: # By default authentiction is needed when user/password info is found in the
MARTIMM/mongo-perl6-driver:323: and (? $!uri-data<username> or ? $!uri-data<password>) {
MARTIMM/mongo-perl6-driver:349: :password($!uri-data<password>),
MARTIMM/mongo-perl6-driver:19: token server-section { <username-password>? <server-list>? }
MARTIMM/mongo-perl6-driver:21: token username-password {
MARTIMM/mongo-perl6-driver:22: $<username>=<[\w\d%-]>+ ':' $<password>=<[\w\d%-]>+ '@'
MARTIMM/mongo-perl6-driver:59: method username-password (Match $m) {
MARTIMM/mongo-perl6-driver:61: $!pword = uri-unescape(~$m<password>);
MARTIMM/mongo-perl6-driver:103: $!server-data<password> = $actions.pword;
MARTIMM/mongo-perl6-driver:74: subtest "mongodb url with username and password SCRAM-SHA-1", {
MARTIMM/mongo-perl6-driver:85: ok .message ~~ m:s/Password too 'short,' must be '>= 6'/,
MARTIMM/mongo-perl6-driver:86: 'Password too short';
MARTIMM/mongo-perl6-driver:100: ok .message ~~ m:s/Password does not have the right properties/,
MARTIMM/mongo-perl6-driver:101: 'Password does not have the right properties';
MARTIMM/mongo-perl6-driver:117: }, "Test username and password checks";
MARTIMM/mongo-perl6-driver:138: :password<mt+++>,
MARTIMM/mongo-perl6-driver:50: method mangle-password ( Str:D :$username, Str:D :$password --> Buf ) {
MARTIMM/mongo-perl6-driver:52: my utf8 $mdb-hashed-pw = ($username ~ ':mongo:' ~ $password).encode;
MARTIMM/mongo-perl6-driver:67: :password<pencil>,
MARTIMM/mongo-perl6-driver:199: method mangle-password ( Str:D :$username, Str:D :$password --> Buf ) {
MARTIMM/mongo-perl6-driver:201: my utf8 $mdb-hashed-pw = ($username ~ ':mongo:' ~ $password).encode;
MARTIMM/mongo-perl6-driver:244: :password<w@tD8jeDan>,
MARTIMM/mongo-perl6-driver:21: is $uri.server-data<password>, '', 'mongodb:// --> no password';
MARTIMM/mongo-perl6-driver:87: is $uri.server-data<password>, 'pw', 'mongodb://mt:pw@ --> password = pw';
MARTIMM/mongo-perl6-driver:94: is $uri.server-data<password>, 'pw', 'mongodb://mt:pw@h2:9876/users --> password = pw';
MARTIMM/mongo-perl6-driver:99: is $uri.server-data<password>, 'w@tD8jeDan', 'mongodb://Dondersteen:w%40tD8jeDan@h2:9876/users --> password = w@tD8jeDan';
MARTIMM/mongo-perl6-driver:19: mongodb://[username:password@]host1[:port1][,host2[:port2],...[,hostN[:portN]]][/[database][?options]]
MARTIMM/mongo-perl6-driver:50: mongodb://[username:password@][host1][:port1],...[,[hostN][:portN]][/[database][?options]]
MARTIMM/mongo-perl6-driver:75: $|h2 [ Username and password ]
MARTIMM/mongo-perl6-driver:85: $!test.add t='is $uri-obj.server-data<password>, "pencil"' [
MARTIMM/mongo-perl6-driver:86: Password found in uri is $*|code[pencil].
MARTIMM/mongo-perl6-driver:90: It is not correct to specify the username without its password.
MARTIMM/mongo-perl6-driver:29: is $uri-obj.server-data<password>, "pencil", 'T7';
MARTIMM/mongo-perl6-driver:44: :username<user>, :password<pencil>,
MARTIMM/mongo-perl6-driver:55: $!test.add t='is $cred.password, "pencil"' [
MARTIMM/mongo-perl6-driver:67: :username<user>, :password<pencil>, :auth-mechanism<MONGODB-X509>
MARTIMM/mongo-perl6-driver:72: Mechanism $**code[MONGODB-X509] does not expect a password
MARTIMM/mongo-perl6-driver:76: $cred .= new( :password<pencil>, :auth-mechanism<MONGODB-CR>);
MARTIMM/mongo-perl6-driver:95: The driver will not show much if no user or password is given. So, in order
MARTIMM/mongo-perl6-driver:17: :username<user>, :password<pencil>,
MARTIMM/mongo-perl6-driver:21: is $cred.password, "pencil", 'T1';
MARTIMM/mongo-perl6-driver:24: :username<user>, :password<pencil>, :auth-mechanism<MONGODB-X509>
MARTIMM/mongo-perl6-driver:29: $cred .= new( :password<pencil>, :auth-mechanism<MONGODB-CR>);
MARTIMM/unicode-precis:42: * rfc4013 - SASLprep: Stringprep Profile for User Names and Passwords
MARTIMM/unicode-precis:43: * [rfc7613 - Preparation, Enforcement, and Comparison of Internationalized Strings Representing Usernames and Passwords](https://tools.ietf.org/html/rfc7613#section-3.1) Obsoletes rfc4013.
MARTIMM/unicode-precis:71: First the basis of the PRECIS framework will be build. As soon as possible a profile for usernames and passwords follows. This is my first need. When this functions well enough, other profiles can be inserted. Much of it is now Implemented.
MARTIMM/unicode-precis:8: # characters that is used for free-form strings, including passwords as well
MARTIMM/unicode-precis:14: # Applicability: Passwords and other opaque strings in security and
MARTIMM/unicode-precis:274: my Str $password = 'correct horse battery staple';
MARTIMM/unicode-precis:275: my TestValue $tv = $psff.prepare($password);
MARTIMM/unicode-precis:276: ok (($tv ~~ Str) and ($tv eq $password)), "test password '$tv'";
MARTIMM/unicode-precis:279: $password = 'Correct Horse Battery Staple';
MARTIMM/unicode-precis:280: $tv = $psff.prepare($password);
MARTIMM/unicode-precis:281: ok (($tv ~~ Str) and ($tv eq $password)), "test password '$tv'";
MARTIMM/unicode-precis:284: $password = "\x03C0\x00DF\x00E5";
MARTIMM/unicode-precis:285: $tv = $psff.prepare($password);
MARTIMM/unicode-precis:286: ok (($tv ~~ Str) and ($tv eq $password)), "test password '$tv'";
MARTIMM/unicode-precis:289: $password = "Jack of \x2666";
MARTIMM/unicode-precis:290: $tv = $psff.prepare($password);
MARTIMM/unicode-precis:291: ok (($tv ~~ Str) and ($tv eq $password)), "test password '$tv'";
MARTIMM/unicode-precis:294: $password = "Foo\x[1680]Bar";
MARTIMM/unicode-precis:295: my Str $password2 = "Foo Bar";
MARTIMM/unicode-precis:296: $tv = $psff.enforce($password);
MARTIMM/unicode-precis:297: ok (($tv ~~ Str) and ($tv eq $password2)), "test password '$tv'";
MARTIMM/unicode-precis:300: $password = "my cat is a \x[0009]by";
MARTIMM/unicode-precis:301: $tv = $psff.enforce($password);
MARTIMM/unicode-precis:302: ok (($tv ~~ Bool) and not $tv), "test password '$password' fails";
MARTIMM/unicode-precis:304: $password = 'Upper Case';
MARTIMM/unicode-precis:305: $tv = $psff.compare( $password, lc($password));
MARTIMM/unicode-precis:306: ok !$tv, 'Passwords not equal';
MattOates/Text--Emotion:377: password, or within a similar access control scheme provided that You
Perl6-Noise-Gang/Audio-PortAudio:15: stream-source --password=<source pw>
Perl6-Noise-Gang/Audio-PortAudio:31: specify the icecast password (you did actually change that right?) You
Perl6-Noise-Gang/Audio-PortAudio:58: sub MAIN(Str :$host = 'localhost', Int :$port = 8000, Str :$user = 'source', Str :$password!, Int :$bitrate = 128, Int :$quality = 5, Str :$mount = '/stream', Str :$source, Int :$buffer = 256, *%extra) {
Perl6-Noise-Gang/Audio-PortAudio:92: my $shout = Audio::Libshout.new(:$host, :$port, :$user, :$password, :$mount, :$format, |%extra);
PostCocoon/P6-Url:120: <username> [ ':' <password> ]?
PostCocoon/P6-Url:135: token password {
PostCocoon/P6-Url:181: $result<password> [R//]= ~$grammar<auth><password>;
PostCocoon/P6-Url:200: if defined $hash<password> {
PostCocoon/P6-Url:201: $url ~= ":" ~ $hash<password>
ShaneKilkelly/perl6-config-clever:31: "password": null,
ShaneKilkelly/perl6-config-clever:41: "password": "a_terrible_password",
ShaneKilkelly/perl6-config-clever:63: # "password": "a_terrible_password",
ShaneKilkelly/perl6-config-clever:10: "password": "password"
ShaneKilkelly/perl6-config-clever:38: password => "password"
Skarsnik/perl6-discord:50: method login(Str $mail, Str $password) returns Bool {
Skarsnik/perl6-discord:51: my $rep = self.post(%api-url<login>, email => $mail, password => $password);
TiMBuS/Net--IRC:35: Autoident.new(password => 'nspassw0rd')
TiMBuS/Net--IRC:64: $password;
TiMBuS/Net--IRC:19: has $.password;
TiMBuS/Net--IRC:65: $.conn.sendln("PASS $.password", scrubbed => 'PASS ...')
TiMBuS/Net--IRC:66: if $.password;
TiMBuS/Net--IRC:6: has $.password = die "Need to tell Autoident your password if you want it to work!";
TiMBuS/Net--IRC:9: $ev.conn.sendln("NS IDENTIFY $.password", scrubbed => 'NS IDENTIFY ...');
adaptiveoptics/HTML-Tag:163: {password => { type => 'password' }},
adaptiveoptics/HTML-Tag:163: {password => { type => 'password' }},
adaptiveoptics/HTML-Tag:38: unless %tagdef<type> eq 'password' {
adaptiveoptics/HTML-Tag:43: unless %tagdef<type>:exists and (%tagdef<type> eq 'password') {
adaptiveoptics/HTML-Tag:94: {password => { type => 'password' }},
adaptiveoptics/HTML-Tag:217: the type is "password" no value attribute will ever be printed for the
adaptiveoptics/HTML-Tag:15: { password => { }},
adaptiveoptics/HTML-Tag:22: is $form.render, '<form method="POST" name="form" action="/"><input name="username" id="form-username" type="text"><input name="password" i…
adaptiveoptics/HTML-Tag:25: { password => { }},
adaptiveoptics/HTML-Tag:32: is $form.render, '<form method="POST" name="form" action="/"><input name="username" id="form-username" type="text" autofocus><input name="pass…
adaptiveoptics/HTML-Tag:36: is $form.render, '<form method="POST" name="form" action="/"><label for="form-username">Username</label><input name="username" id="form-username" typ…
adaptiveoptics/HTML-Tag:39: { password => { }},
adaptiveoptics/HTML-Tag:47: is $form.render, '<form method="POST" name="form" action="/"><label for="form-username">Username</label><input name="username" id="form-username" typ…
adaptiveoptics/HTML-Tag:54: is $form.render, '<form method="POST" name="form" action="/"><input name="username" id="form-username" type="text" value="mark"><input name="p…
adaptiveoptics/HTML-Tag:57: { password => { type => 'password' }},
adaptiveoptics/HTML-Tag:64: %input<password> = 'supersecret';
adaptiveoptics/HTML-Tag:68: is $form.render, '<form method="POST" name="form" action="/"><label for="form-username">Username</label><input name="username" id="form-username" typ…
adaptiveoptics/HTML-Tag:74: { password => { type => 'password' }},
adaptiveoptics/HTML-Tag:83: is $form.render, '<form method="POST" name="form" action="/"><label for="form-username">Username</label><input name="username" id="form-username" typ…
adaptiveoptics/HTML-Tag:86: { password => { type => 'password' }},
adaptiveoptics/HTML-Tag:94: is $form.render, '<form method="POST" name="form" action="/"><span>oofie<label for="form-username">Username</label><input name="username" id="form-us…
adaptiveoptics/HTML-Tag:100: { password => { }},
adaptiveoptics/HTML-Tag:107: is $form.render, '<form method="POST" name="form" action="/"><input name="username" id="form-username" type="text" required><input name="passw…
adaptiveoptics/HTML-Tag:112: { password => { attrs => {:id('blue')} }},
adaptiveoptics/HTML-Tag:119: is $form.render, '<form method="POST" name="form" action="/"><input name="username" id="form-username" class="pink" type="text"><input name="p…
adaptiveoptics/HTML-Tag:124: { password => { }},
adaptiveoptics/HTML-Tag:132: is $form.render, '<form method="POST" name="form" action="/"><input name="username" id="form-username" type="text"><input name="password" i…
adaptiveoptics/HTML-Tag:137: { password => { }},
adaptiveoptics/HTML-Tag:146: is $form.render, '<form method="POST" name="form" action="/"><input name="username" id="form-username" type="text"><input name="password" i…
adaptiveoptics/HTML-Tag:153: { password => { }},
adaptiveoptics/HTML-Tag:162: is $form.render, '<form method="POST" name="form" action="/"><input name="username" id="form-username" type="text"><input name="password" i…
adaptiveoptics/HTML-Tag:169: { password => { }},
adaptiveoptics/HTML-Tag:177: is $form.render, '<form method="POST" name="form" action="/"><input name="username" id="form-username" type="text"><input name="password" i…
afiskon/p6-sitemap-xml-parser:69: <loc>http://username:password@xn--d1abbgf6aiiy.xn--p1ai:8080/</loc>
afiskon/p6-sitemap-xml-parser:84: loc => 'http://username:password@xn--d1abbgf6aiiy.xn--p1ai:8080/',
araraloren/Net-FTP:541: Ftp user's password. If password is not given or a empty string, and the user is anonymous, anonymous@ will be
araraloren/Net-FTP:542: the password of user.
azawawi/farabi6:168: type: ["hidden", "text", "search", "tel", "url", "email", "password", "datetime", "date", "month",
azawawi/farabi6:296: keywords: set(sqlKeywords + "accessible action add after algorithm all analyze asensitive at authors auto_increment autocommit avg avg_row_length…
azawawi/farabi6:312: keywords: set(sqlKeywords + "accessible action add after algorithm all always analyze asensitive at authors auto_increment autocommit avg avg_row…
azawawi/farabi6:2: !function(a,b){"object"==typeof module&&"object"==typeof module.exports?module.exports=a.document?b(a,!0):function(a){if(!a.document)throw new Error(…
azawawi/farabi6:4: },removeAttr:function(a,b){var c,d,e=0,f=b&&b.match(E);if(f&&1===a.nodeType)while(c=f[e++])d=n.propFix[c]||c,n.expr.match.bool.test(c)&&(a[d]=!1),a.r…
azawawi/farabi6:10: */.ui.form{position:relative;max-width:100%}.ui.form>p{margin:1em 0}.ui.form .field,.ui.form .fields .field{clear:both;margin:0 0 1em}.ui.form .fiel…
azawawi/farabi6:10: */*,:after,:before{box-sizing:inherit}html{box-sizing:border-box}input[type=text],input[type=email],input[type=search],input[type=password…
azawawi/farabi6:11: @import 'https://fonts.googleapis.com/css?family=Lato:400,700,400italic,700italic&subset=latin';*,:after,:before{box-sizing:inherit}html{box-sizing:b…
azawawi/perl6-electron:23: * hash: string user password
azawawi/perl6-electron:15: * hash: string rpc password (hash), default null
azawawi/perl6-electron:136: * hash: string user password, default null
azawawi/perl6-electron:10: // string rpc password (hash), default null
azawawi/perl6-gtk-scintilla:6774: <span class="S0"> </span>WordListSet<span class="S10">(</span><span class="S5">int</span><span class="S0"> </span>n<span class="S10">,</spa…
azawawi/perl6-gtk-scintilla:8077: EM_GETPASSWORDCHAR EM_SETPASSWORDCHAR
azawawi/perl6-gtk-scintilla:1431: #define SCE_PAS_WORD 9
azawawi/perl6-gtk-scintilla:4367: val SCE_PAS_WORD=9
azawawi/perl6-gtk-scintilla:181: sc.ChangeState(SCE_PAS_WORD);
azawawi/perl6-gtk-scintilla:208: sc.ChangeState(SCE_PAS_WORD);
azawawi/perl6-gtk-scintilla:571: if (stylePrev != SCE_PAS_WORD && style == SCE_PAS_WORD)
azawawi/perl6-gtk-scintilla:576: if (stylePrev == SCE_PAS_WORD && !(lineFoldStateCurrent & stateFoldInPreprocessor)) {
azawawi/perl6-libzip:108: # N No password provided
azawawi/perl6-libzip:110: # N Wrong password provided
azawawi/perl6-libzip:440: #ZIP_EXTERN int zip_set_default_password(struct zip *, const char *);
azawawi/perl6-libzip:441: sub zip_set_default_password(Pointer[zip] # zip*
azawawi/perl6-net-curl:13: user+password authentication (Basic, Digest, NTLM, Negotiate, Kerberos),
azawawi/perl6-net-curl:160: /* set user name and password for the authentication */
azawawi/perl6-net-curl:161: curl_easy_setopt(curl, CURLOPT_USERPWD, "user:password");
azawawi/perl6-net-curl:101: " -envpass arg - environement variable which content the tia private key password",
azawawi/perl6-net-curl:32: /* Set username and password */
azawawi/perl6-net-curl:33: curl_easy_setopt(curl, CURLOPT_USERPWD, "user:password");
azawawi/perl6-net-curl:32: /* Set username and password */
azawawi/perl6-net-curl:33: curl_easy_setopt(curl, CURLOPT_USERPWD, "user:password");
azawawi/perl6-net-curl:32: /* Set username and password */
azawawi/perl6-net-curl:33: curl_easy_setopt(curl, CURLOPT_USERPWD, "user:password");
azawawi/perl6-net-curl:33: #define PASSWORD "123qwerty"
azawawi/perl6-net-curl:121: curl_easy_setopt(curl, CURLOPT_PASSWORD, PASSWORD);
azawawi/perl6-net-curl:114: * authentication details (user names and passwords) from being "snooped"
azawawi/perl6-net-curl:115: * on the network. Here is how the user name and password are provided: */
azawawi/perl6-net-curl:117: curl_easy_setopt(curl, CURLOPT_PASSWORD, "P@ssw0rd");
azawawi/perl6-net-curl:181: char *proxy_user_password)
azawawi/perl6-net-curl:186: if (strlen(proxy_user_password) > 0)
azawawi/perl6-net-curl:187: curl_easy_setopt(curl, CURLOPT_PROXYUSERPWD, proxy_user_password);
azawawi/perl6-net-curl:229: " password.\n");
azawawi/perl6-net-curl:243: conf->proxy_user[i] = 0; /* Clean up password from memory */
azawawi/perl6-net-curl:170: constant CURLOPT_PASSWORD is export = 10174;
azawawi/perl6-net-curl:172: constant CURLOPT_PROXYPASSWORD is export = 10176;
azawawi/perl6-net-curl:201: constant CURLOPT_TLSAUTH_PASSWORD is export = 10205;
azawawi/perl6-net-curl:406: CURLOPT_PASSWORD => 10174,
azawawi/perl6-net-curl:408: CURLOPT_PROXYPASSWORD => 10176,
azawawi/perl6-net-curl:437: CURLOPT_TLSAUTH_PASSWORD => 10205,
azawawi/perl6-odoo-client:19: password => "<password>"
azawawi/perl6-odoo-client:20: password => "<password>"
azawawi/perl6-odoo-client:47: ### login(Str :$database, Str :$username, Str :$password) {
azawawi/perl6-odoo-client:18: password => "123"
azawawi/perl6-odoo-client:18: password => "123"
azawawi/perl6-odoo-client:26: password => "<password>"
azawawi/perl6-odoo-client:44: has Str $!password;
azawawi/perl6-odoo-client:76: =head3 login(Str :$database, Str :$username, Str :$password) {
azawawi/perl6-odoo-client:80: method login(Str :$database, Str :$username, Str :$password) {
azawawi/perl6-odoo-client:84: args => [$database, $username, $password]
azawawi/perl6-odoo-client:89: $!password = $password;
azawawi/perl6-odoo-client:101: my @args = [$!database, $!uid, $!password, $model, $method, $method-args];
azawawi/perl6-parse-selenese:36: <td>name=password</td>
azawawi/perl6-parse-selenese:26: <td>name=password</td>
azawawi/perl6-parse-selenese:35: <td>name=password</td>
bbkr/jsonrpc:116: return 'username', 'password';
cbk/WebService-GoogleDyDNS:27: multi sub MAIN( :$domain, :$login, :$password ) {
cbk/WebService-GoogleDyDNS:29: my $updater = WebService::GoogleDyDNS.new(domainName => $domain, login => $login , password => $password );
cbk/WebService-GoogleDyDNS:37: multi sub MAIN( :$domain, :$login, :$password ) {
cbk/WebService-GoogleDyDNS:39: my $updater = WebService::GoogleDyDNS.new(domainName => $domain, login => $login , password => $password );
cbk/WebService-GoogleDyDNS:19: has %.password is rw;
cbk/WebService-GoogleDyDNS:27: token line { <domainKey> \t <lastipKey> \t <loginKey> \t <passwordKey> };
cbk/WebService-GoogleDyDNS:31: token passwordKey { 'password' \t <PASSWORD> };
cbk/WebService-GoogleDyDNS:35: token PASSWORD { \w+ };
cbk/WebService-GoogleDyDNS:50: %.password = 'password' => $match<line><passwordKey><PASSWORD>;
cbk/WebService-GoogleDyDNS:51: @dataSet[$elemNum] = ( %.domainName ~ "\t" ~ %.lastIP ~ "\t" ~ %.login ~ "\t" ~ %.password);
cbk/WebService-GoogleDyDNS:88: $webAgent.auth(self.login.values(), self.password.values() );
cbk/WebService-GoogleDyDNS:101: $fh.say( self.password.values() );
cspencer/perl6-posix:19: * getpwnam(Str $username) - Returns an anonymous class containing the broken-out fields of the record in the password database (e.g., th…
cspencer/perl6-posix:21: * getgrnam(Str $group) - Returns an anonymous class containing the broken-out fields of the record in the group database that matches the provided group name. The class has the following accessor methods: name, password, gid, and members.
cspencer/perl6-posix:23: * getgrgid(gid_t $gid) - Returns an anonymous class containing the broken-out fields of the record in the group database that matches the provided group id. The class has the following accessor methods: name, password, gid, and members.
cspencer/perl6-posix:11: has Str $.password;
cspencer/perl6-posix:21: has Str $.password;
cspencer/perl6-posix:36: has Str $.password;
cspencer/perl6-posix:18: ok($pwnam.password.isa(Str), ".password isa Str");
cspencer/perl6-posix:15: ok($group.password.isa(Str), ".password isa Str");
cygx/p6-tinycc-resources-win64:2610: WINADVAPI WINBOOL WINAPI LogonUserA(LPCSTR lpszUsername,LPCSTR lpszDomain,LPCSTR lpszPassword,DWORD dwLogonType,DWORD dwLogonProvider,PHANDLE phToken);
cygx/p6-tinycc-resources-win64:2611: WINADVAPI WINBOOL WINAPI LogonUserW(LPCWSTR lpszUsername,LPCWSTR lpszDomain,LPCWSTR lpszPassword,DWORD dwLogonType,DWORD dwLogonProvider,PHANDLE phToken);
cygx/p6-tinycc-resources-win64:2612: WINADVAPI WINBOOL WINAPI LogonUserExA(LPCSTR lpszUsername,LPCSTR lpszDomain,LPCSTR lpszPassword,DWORD dwLogonType,DWORD dwLogonProvider,PHANDLE phToken,PSID *ppLogonSid,PVOID *ppProfileBuffer,LPDWORD pdwProfileLength,PQUOTA_LIMITS pQuotaLimits);
cygx/p6-tinycc-resources-win64:2613: WINADVAPI WINBOOL WINAPI LogonUserExW(LPCWSTR lpszUsername,LPCWSTR lpszDomain,LPCWSTR lpszPassword,DWORD dwLogonType,DWORD dwLogonProvider,PHANDLE phToken,PSID *ppLogonSid,PVOID *ppProfileBuffer,LPDWORD pdwProfileLength,PQUOTA_LIMITS pQuotaLimits);
cygx/p6-tinycc-resources-win64:2620: #define LOGON_ZERO_PASSWORD_BUFFER 0x80000000
cygx/p6-tinycc-resources-win64:2622: WINADVAPI WINBOOL WINAPI CreateProcessWithLogonW(LPCWSTR lpUsername,LPCWSTR lpDomain,LPCWSTR lpPassword,DWORD dwLogonFlags,LPCWSTR lpAppl…
cygx/p6-tinycc-resources-win64:108: #define ERROR_INVALID_PASSWORD 86L
cygx/p6-tinycc-resources-win64:386: #define ERROR_INVALID_PASSWORDNAME 1216L
cygx/p6-tinycc-resources-win64:456: #define ERROR_NULL_LM_PASSWORD 1304L
cygx/p6-tinycc-resources-win64:475: #define ERROR_WRONG_PASSWORD 1323L
cygx/p6-tinycc-resources-win64:476: #define ERROR_ILL_FORMED_PASSWORD 1324L
cygx/p6-tinycc-resources-win64:477: #define ERROR_PASSWORD_RESTRICTION 1325L
cygx/p6-tinycc-resources-win64:482: #define ERROR_PASSWORD_EXPIRED 1330L
cygx/p6-tinycc-resources-win64:801: #define ERROR_PASSWORD_MUST_CHANGE 1907L
cygx/p6-tinycc-resources-win64:850: #define ERROR_CONNECTED_OTHER_PASSWORD 2108L
cygx/p6-tinycc-resources-win64:851: #define ERROR_CONNECTED_OTHER_PASSWORD_DEFAULT 2109L
cygx/p6-tinycc-resources-win64:1416: #define ERROR_DS_SAM_NEED_BOOTKEY_PASSWORD 8529L
cygx/p6-tinycc-resources-win64:3843: #define ES_PASSWORD 0x0020L
cygx/p6-tinycc-resources-win64:3900: #define EM_SETPASSWORDCHAR 0x00CC
cygx/p6-tinycc-resources-win64:3906: #define EM_GETPASSWORDCHAR 0x00D2
dnmfarrell/System-Passwd:23: my $password_file = open '/etc/passwd', :r;
dnmfarrell/System-Passwd:25: for $password_file.lines
dnmfarrell/System-Passwd:4: has $.password;
dnmfarrell/System-Passwd:15: my $password = @line[1];
dnmfarrell/System-Passwd:22: return self.bless(:$username, :$password, :$uid, :$gid, :$fullname, :$home_directory, :$login_shell);
dnmfarrell/System-Passwd:17: is $user.password, @line[2], "password is {@line[2]}";
fayland/perl6-WebService-GitHub:39: * `auth_login` & `auth_password`
fayland/perl6-WebService-GitHub:123: auth_password => 'password'
fayland/perl6-WebService-GitHub:9: auth_password => %*ENV<GITHUB_PASS>
fayland/perl6-WebService-GitHub:24: has $.auth_password;
fayland/perl6-WebService-GitHub:80: if $.auth_login.defined && $.auth_password.defined {
fayland/perl6-WebService-GitHub:82: Authorization => "Basic " ~ MIME::Base64.encode-str("{$.auth_login}:{$.auth_password}")
finanalyst/p6-inform:85: An entry widget can mask input, as in password requests, by adding _pw or -pw onto the
finanalyst/p6-inform:88: my $login = inform('Please supply your username and password',
finanalyst/p6-inform:89: :entries(un => 'User name', pw_pw => 'Password')
finanalyst/p6-inform:92: if $login.response eq 'OK' { say "user name is \<{$login.data<un>}> and password is \<{$login.data<pw_pw>}>" };
finanalyst/p6-inform:77: An entry widget can mask input, as in password requests, by adding _pw or -pw onto the
finanalyst/p6-inform:80: my $login = inform('Please supply your username and password',
finanalyst/p6-inform:81: :entries(un => 'User name', pw_pw => 'Password')
finanalyst/p6-inform:84: if $login.response eq 'OK' { say "user name is \<{$login.data<un>}> and password is \<{$login.data<pw_pw>}>" };
finanalyst/p6-inform:90: # treat passwords differently
gfldex/perl6-meta6-bin:100: instead of a password.
gfldex/perl6-pod-to-bigpage:10054: [passwords]
gfldex/perl6-pod-to-bigpage:10055: jack=password1
gfldex/perl6-pod-to-bigpage:10074: # ("passwords" => {"jack" => "password1", "joy" => "muchmoresecure123"},
gfldex/perl6-pod-to-bigpage:10361: [passwords]
gfldex/perl6-pod-to-bigpage:10362: jack = password1
gfldex/perl6-typesafe-xhtml-writer:1672: <xs:enumeration value="password"/>
gfldex/perl6-xhtml-writer:1672: <xs:enumeration value="password"/>
goneri/p6-Email-Notmuch:340: source code form), and must require no special password or key for
jnthn/p6-docker-file:38: # Setup a password
jnthn/p6-http-hpack:21: name => 'password',
jnthn/p6-http-hpack:67: [ header('password', 'secret', HTTP::HPACK::Indexing::NeverIndexed) ],
jnthn/p6-http-hpack:68: 'decode password: secret';
jnthn/p6-http-hpack:70: [ header('password', 'secret', HTTP::HPACK::Indexing::NeverIndexed) ]),
jnthn/p6-http-hpack:73: 'encode password: secret (never indexed)';
jnthn/p6-ssh-libssh:8: private key; you can also provide a private key file or a password)
jnthn/p6-ssh-libssh:10: Int :$port = 22, Str :$password, Str :$private-key-file) {
jnthn/p6-ssh-libssh:11: my $session = await SSH::LibSSH.connect(:$host, :$user, :$port, :$private-key-file, :$password);
jnthn/p6-ssh-libssh:11: Int :$port = 22, Str :$password, Str :$private-key-file) {
jnthn/p6-ssh-libssh:12: my $session = await SSH::LibSSH.connect(:$host, :$user, :$port, :$private-key-file, :$password);
jnthn/p6-ssh-libssh:3: sub MAIN(Str $host, Str $user, Int :$port = 22, Str :$password, Str :$private-key-file, *@command) {
jnthn/p6-ssh-libssh:4: my $session = await SSH::LibSSH.connect(:$host, :$user, :$port, :$private-key-file, :$password);
jnthn/p6-ssh-libssh:3: sub MAIN($host, $user, $remote, $local, Int :$port, Str :$password) {
jnthn/p6-ssh-libssh:4: my $session = await SSH::LibSSH.connect(:$host, :$user, :$port, :$password);
jnthn/p6-ssh-libssh:3: sub MAIN($host, $user, $local, $remote, Int :$port, Str :$password) {
jnthn/p6-ssh-libssh:4: my $session = await SSH::LibSSH.connect(:$host, :$user, :$port, :$password);
jnthn/p6-ssh-libssh:191: has Str $!password;
jnthn/p6-ssh-libssh:201: Str :$!private-key-file = Str, Str :$!password = Str,
jnthn/p6-ssh-libssh:420: if $method eq "key" and defined $!password {
jnthn/p6-ssh-libssh:421: # Public Key authentication failed. We'll try using a password now.
jnthn/p6-ssh-libssh:422: self!connect-auth-user-password($v);
jnthn/p6-ssh-libssh:430: method !connect-auth-user-password($v) {
jnthn/p6-ssh-libssh:432: my &auth-function = { ssh_userauth_password($s, Str, $!password) }
jnthn/p6-ssh-libssh:435: self!process-auth-outcome($auth-outcome, $v, :method<password>);
jnthn/p6-ssh-libssh:442: self!process-auth-outcome($auth-outcome, $v, :method<password>);
jnthn/p6-ssh-libssh:115: sub ssh_userauth_password(SSHSession, Str, Str) returns int32
jonathanstowe/Audio-Icecast:43: method new(Str :$host = 'localhost', Int :$port = 8000, Bool :$secure = False, Str :$user = 'admin', Str :$password = 'hackme')
jonathanstowe/Audio-Icecast:45: The constructor for the class supplies defaults that will work with a stock configuration on the local machine, this probably isn't what you want, be…
jonathanstowe/Audio-Icecast:7: sub MAIN(Str :$mount!, Str :$host = 'localhost', Int :$port = 8000, Str :$user = 'admin', Str :$password = 'hackme') {
jonathanstowe/Audio-Icecast:8: my $ai = Audio::Icecast.new(:$host, :$port, :$user, :$password);
jonathanstowe/Audio-Icecast:7: sub MAIN(Str :$mount!, Str :$title!, Str :$host = 'localhost', Int :$port = 8000, Str :$user = 'admin', Str :$password = 'hackme') {
jonathanstowe/Audio-Icecast:8: my $ai = Audio::Icecast.new(:$host, :$port, :$user, :$password);
jonathanstowe/Audio-Icecast:57: method new(Str :$host = 'localhost', Int :$port = 8000, Bool :$secure = False, Str :$user = 'admin', Str :$password = 'hackme')
jonathanstowe/Audio-Icecast:61: want, because at the very least you changed the password right? If you
jonathanstowe/Audio-Icecast:386: submethod BUILD(Str :$host = 'localhost', Int :$port = 8000, Bool :$secure = False, Str :$user = 'admin', Str :$password = 'hackme') {
jonathanstowe/Audio-Icecast:388: $!ua.auth($user, $password);
jonathanstowe/Audio-Icecast:12: my $password = %*ENV<ICECAST_TEST_PASS> // 'hackme';
jonathanstowe/Audio-Icecast:17: lives-ok { $obj = Audio::Icecast.new(:$host, :$port, :$user, :$password) }, "get object with full credentials";
jonathanstowe/Audio-Libshout:11: my $shout = Audio::Libshout.new(password => 'hackme', mount => '/foo', format => Audio::Libshout::Format::MP3);
jonathanstowe/Audio-Libshout:60: If the stream is not already connected this will open the stream so that data can be sent. The `host`, `port`, `user` and `password` and ot…
jonathanstowe/Audio-Libshout:157: password
jonathanstowe/Audio-Libshout:160: The password that is used to authenticate with the server. There is no default and this must be provided before connecting.
jonathanstowe/Audio-Libshout:60: * SHOUT_TEST_PASS - the password to authenticate with. The default is 'hackme' but you changed that right?
jonathanstowe/Audio-Libshout:7: multi sub MAIN(Str :$host = 'localhost', Int :$port = 8000, Str :$user = 'source', Str :$password!, Str :$mount = '/stream', Str :$file!, *%extra) {
jonathanstowe/Audio-Libshout:25: my $shout = Audio::Libshout.new(:$host, :$port, :$user, :$password, :$mount, :$format, |%extra);
jonathanstowe/Audio-Libshout:10: multi sub MAIN(Str :$host = 'localhost', Int :$port = 8000, Str :$user = 'source', Str :$password!, Int :$bitrate = 128, Int :$quality = 5, Int :$bufsize = 512, Str :$mount = '/stream', Str :$file!, *%extra) {
jonathanstowe/Audio-Libshout:30: my $shout = Audio::Libshout.new(:$host, :$port, :$user, :$password, :$mount, :$format, |%extra);
jonathanstowe/Audio-Libshout:3: my $shout = Audio::Libshout.new(password => 'hackme', mount => '/foo', format => Audio::Libshout::Format::MP3);
jonathanstowe/Audio-Libshout:15: my $shout = Audio::Libshout.new(password => 'hackme', mount => '/foo', format => Audio::Libshout::Format::MP3);
jonathanstowe/Audio-Libshout:81: that data can be sent. The C<host>, C<port>, C<user> and C<password>
jonathanstowe/Audio-Libshout:228: =head2 password
jonathanstowe/Audio-Libshout:230: The password that is used to authenticate with the server. There is no default and this
jonathanstowe/Audio-Libshout:476: sub shout_set_password(Shout, Str) returns int32 is native('shout',v3) { * }
jonathanstowe/Audio-Libshout:477: sub shout_get_password(Shout) returns Str is native('shout',v3) { * }
jonathanstowe/Audio-Libshout:479: method password() returns Str is rw is accessor-facade(&shout_get_password, &shout_set_password, &manage, &check) { }
jonathanstowe/Audio-Libshout:584: has Shout $!shout handles <host port user password protocol format mount dumpfile agent public name url genre description>;
jonathanstowe/Audio-Libshout:14: { name => "password", value => 'hackme' },
jonathanstowe/Audio-Libshout:35: throws-like { $obj.open }, X::ShoutError, "open without password should fail";
jonathanstowe/Audio-Libshout:37: $obj.password = 'S0me8oGusP455w0RD!%';
jonathanstowe/Audio-Libshout:39: throws-like { $obj.open }, rx/"The server refused login, probably because authentication failed"/, "open with wrong password should fail";
jonathanstowe/Audio-Libshout:41: $obj.password = $pass;
jonathanstowe/Audio-Libshout:43: lives-ok { $obj.open }, "open with good password";
jonathanstowe/Audio-Libshout:55: lives-ok { $obj = Audio::Libshout.new(user => $user, password => $pass, host => $host, port => $port, mount => $mount) }, "new to test sending " ~ $test<file>;
jonathanstowe/Audio-Libshout:81: lives-ok { $obj = Audio::Libshout.new(user => $user, password => $pass, host => $host, port => $port, mount => $mount) }, "new to test sending " ~ $test<file>;
jonathanstowe/Audio-Liquidsoap:22: output.icecast(%mp3,host="localhost",port=8000,password="hackme",mount="radio", radio)
jonathanstowe/Audio-Liquidsoap:11: output.icecast(%mp3, host="localhost",port=8000,password="hackme",mount="radio", radio)
jonathanstowe/Audio-Liquidsoap:15: output.icecast(%mp3, host="localhost",port=8000,password="hackme",mount="radio", radio)
jonathanstowe/Crypt-Libcrypt:21: "password"
jonathanstowe/Crypt-Libcrypt:15: passwords on a Unix system.
jonathanstowe/Crypt-Libcrypt:17: Because this is intended primarily for the encryption of passwords and is
jonathanstowe/Crypt-Libcrypt:21: In order to check whether a password entered by a user is correct it should
jonathanstowe/Crypt-Libcrypt:22: be encrypted using the stored encrypted password as the "salt" - the result
jonathanstowe/Crypt-Libcrypt:23: will be the same as the stored crypt text if the password is the same.
jonathanstowe/Crypt-Libcrypt:19: my $crypted = crypt($password, $salt );
jonathanstowe/Crypt-Libcrypt:35: used to encrypt passwords on a Unix system.
jonathanstowe/Crypt-Libcrypt:37: Because this is intended primarily for the encryption of passwords and
jonathanstowe/Crypt-Libcrypt:41: In order to check whether a password entered by a user is correct it
jonathanstowe/Crypt-Libcrypt:42: should be encrypted using the stored encrypted password as the "salt"
jonathanstowe/Crypt-Libcrypt:43: - the result will be the same as the stored crypt text if the password
jonathanstowe/Lumberjack-Application:34: method new(:$url!, :$username, :$password)
jonathanstowe/Lumberjack-Application:40: Additionally if the C<username> and C<password> parameters
jonathanstowe/Lumberjack-Application:60: has Str $.password;
jonathanstowe/Lumberjack-Application:68: if $!username.defined && $!password.defined {
jonathanstowe/Lumberjack-Application:69: $!ua.auth($!username, $!password);
jonathanstowe/META6:4047: "description" : "Easy bcrypt password hashing",
jonathanstowe/META6:5340: "password"
jonathanstowe/META6:11343: "description" : "Easy Argon2i password hashing",
jonathanstowe/Monitor-Monit:48: * ```MONIT_TEST_PASS``` - the password to authenticate (default ```monit```)
jonathanstowe/Monitor-Monit:36: method new(Str :$host = 'localhost', Int :$port = 2812, Str :$username = 'admin', Str :$password = 'monit', Bool :$secure = False);
jonathanstowe/Monitor-Monit:300: has Str $.password = 'monit';
jonathanstowe/Monitor-Monit:313: has Str $.password = 'monit';
jonathanstowe/Monitor-Monit:362: $!ua = UserAgent.new(:$!host, :$!port, :$!secure, :$!username, :$!password);
jonathanstowe/Monitor-Monit:363: $!ua.auth($!username, $!password);
jonathanstowe/Monitor-Monit:12: my $password = %*ENV<MONIT_TEST_PASS> // 'monit';
jonathanstowe/Monitor-Monit:17: lives-ok { $mon = Monitor::Monit.new(:$host, :$port, :$username, :$password) }, "new with credentials";
jonathanstowe/Pg-Notify:51: * $PG_NOTIFY_PASS - the password to be used, (otherwise no password will be used.)
jonathanstowe/Pg-Notify:19: %args<password> = $pw;
jonathanstowe/Unix-Groups:79: =head2 password
jonathanstowe/Unix-Groups:81: The password for the group if set, most modern systems place this in a
jonathanstowe/Unix-Groups:97: has Str $.password;
jonathanstowe/Unix-Groups:104: $!password = $pass;
jonathanstowe/WebService-Soundcloud:54: my $sc = WebService::Soundcloud.new(:$client-id,:$client-secret,:$username,:$password);
jonathanstowe/WebService-Soundcloud:55: my $sc = WebService::Soundcloud.new(:$client-id,:$client-secret,:$username,:$password);
jonathanstowe/WebService-Soundcloud:84: method new(Str :$!client-id!, Str :$!client-secret!, Str :$!redirect-uri, Str :$!scope, Str :$!username, Str :$!password, HTTP::UserAgent :$!ua )
jonathanstowe/WebService-Soundcloud:89: application with Soundcloud. If C<username> and C<password> are provided then
jonathanstowe/WebService-Soundcloud:326: has Str $.password is rw;
jonathanstowe/WebService-Soundcloud:332: submethod BUILD(Str :$!client-id!, Str :$!client-secret!, Str :$!redirect-uri, Str :$!scope, Str :$!username, Str :$!password, HTTP::UserAgent :$!ua, *%opts) {
jonathanstowe/WebService-Soundcloud:382: if $!username && $!password {
jonathanstowe/WebService-Soundcloud:384: %params<password> = $!password;
jonathanstowe/WebService-Soundcloud:385: %params<grant_type> = 'password';
jonathanstowe/WebService-Soundcloud:12: my $password = %*ENV{'SC_PASSWORD'};
jonathanstowe/WebService-Soundcloud:14: if (defined $username && defined $password)
jonathanstowe/WebService-Soundcloud:21: skip-rest 'No $SC_USERNAME or $SC_PASSWORD defined';
jonathanstowe/WebService-Soundcloud:33: password => $password
jonathanstowe/p6-unix-privileges:30: # once in the chroot access to the system password file is lost
kalkin/License-Software:333: source code form), and must require no special password or key for
kalkin/License-Software:349: source code form), and must require no special password or key for
kalkin/Net-XMPP:19: method new(:$jid!, :$login, :$password, :$server, :$port = 5222, :$socket) {
kalkin/Net-XMPP:20: self.bless(:$jid, :$login, :$password, :$server, :$port, :$socket);
kalkin/Net-XMPP:54: submethod BUILD(:$!jid, :$login is copy, :$password, :$server, :$port, :$!socket){
kalkin/Net-XMPP:72: self!do-negotiation($login, $password);
kalkin/Net-XMPP:75: method !auth($login, $password) {
kalkin/Net-XMPP:86: my $encoded = MIME::Base64.encode-str("\0$login\0$password");
kalkin/Net-XMPP:121: method !do-negotiation($login, $password) {
kalkin/Net-XMPP:122: self!auth($login, $password);
matiaslina/perl6-matrix-client:17: submethod BUILD(:$username!, :$password!, :$home-server!, :@room-ids!, :$on-event!) {
matiaslina/perl6-matrix-client:23: $!client.login($!username, $password);
matiaslina/perl6-matrix-client:67: sub MAIN(Str:D $username, Str:D $password, :$home-server = "https://matrix.deprecated.org") {
matiaslina/perl6-matrix-client:71: password => $password,
matiaslina/perl6-matrix-client:41: type => "m.login.password",
matiaslina/perl6-matrix-client:43: password => $pass
matiaslina/perl6-matrix-client:74: method register($username, $password, Bool :$bind-email? = False) {
matiaslina/perl6-matrix-client:76: username => $username, password => $password,
melezhik/remote-file:34: ## password
melezhik/remote-file:36: Sets password for resources with access restricted by http basic authentication. Optional,
melezhik/remote-file:25: $cmd ~= ':' ~ %args<password> if %args<password>.defined;
melezhik/sparrowdo-chef-manager:34: password => '123456',
melezhik/sparrowdo-chef-manager:56: ## password
melezhik/sparrowdo-chef-manager:58: A chef user password.
melezhik/sparrowdo-chef-manager:17: for 'user-id', 'name', 'email', 'password' -> $p {
melezhik/sparrowdo-chef-manager:27: @params.push: %args<password>;
melezhik/sparrowdo-chef-manager:12: password => '123456',
melezhik/sparrowdo:169: * ssh passwordless access to remote hosts
melezhik/sparrowdo:170: * sudo (passwordless?) rights on remote host
nkh/P6-Data-Dump-Tree:19: [passwords]
nkh/P6-Data-Dump-Tree:20: jack=password1
nkh/P6-Data-Dump-Tree:9: [passwords]
nkh/P6-Data-Dump-Tree:10: jack=password1
nkh/P6-Data-Dump-Tree:30: [passwords]
nkh/P6-Data-Dump-Tree:31: jack=password1
nkh/P6-Data-Dump-Tree:638: 1 = [passwords]\n jack=password1\n (+74)[0..113]
nkh/P6-Data-Dump-Tree:639: <section> [passwords]\n jack=password1\n (+29)[0..68]
nkh/P6-Data-Dump-Tree:640: <header> [passwords]\n[0..15]
nkh/P6-Data-Dump-Tree:641: <0> passwords[5..13]
nkh/P6-Data-Dump-Tree:642: <kvpair> jack=password1\n[16..38]
nkh/P6-Data-Dump-Tree:645: <identifier> password1[29..37]
nkh/P6-Data-Dump-Tree:646: <value> password1[29..37]
nkh/P6-Data-Dump-Tree:19: [passwords]
nkh/P6-Data-Dump-Tree:20: jack=password1
nobodyinperson/perl6-fortran-grammar:340: source code form), and must require no special password or key for
p6-pdf/PDF-p6:325: - `pdf-rewriter.pl [--repair] [--rebuild] [--[un]compress] [--password=Xxx] <pdf-or-json-file-in> [<pdf-or-json-file-out>]`
p6-pdf/PDF-p6:362: To open an encrypted PDF document, specify either the user or owner password: `PDF.open( "enc.pdf", :password<ssh!>)`
p6-pdf/PDF-p6:367: Note that it's quite common to leave the user-password blank. This indicates that the document is readable by anyone, but may have
p6-pdf/PDF-p6:371: passwords may be required, to reopen it.
p6-pdf/PDF-p6:10: Str :$password = ''; #| password for encrypted documents
p6-pdf/PDF-p6:29: $reader.open( $file-in, :$repair, :$password );
p6-pdf/PDF-p6:15: #| 'Standard' is the name of the built-in password-based security handler.
p6-pdf/PDF-p6:49: has Str $.O is entry; #| (Required) A 32-byte string, based on both the owner and user passwords, that is used in computing the encryption key and in determining whether a valid owner password was entered.
p6-pdf/PDF-p6:51: has Str $.U is entry; #| (Required) A 32-byte string, based on the user password, that is used in determining whether to prompt the user for a password and, if so, whether a valid user or owner password was entered.
p6-pdf/PDF-p6:14: has uint8 @!O; #| computed owner password
p6-pdf/PDF-p6:17: has uint8 @!U; #| computed user password
p6-pdf/PDF-p6:281: or die "unable to decrypt this PDF with the given password";
p6-pdf/PDF-p6:106: method !setup-crypt( Str :$password = '') {
p6-pdf/PDF-p6:111: $!crypt.authenticate( $password );
p6-pdf/PDF-p6:93: dies-ok { $crypt.authenticate( 'blah' ) }, "$case - bad password" unless $case eq 'Identity';
p6-pdf/PDF-p6:94: lives-ok { $crypt.authenticate( $user-pass ) }, "$case - user password";
p6-pdf/PDF-p6:96: lives-ok { $crypt.authenticate( $owner-pass, :owner); }, "$case - owner password";
p6-pdf/PDF-p6:20: dies-ok { $pdf = PDF.open: "t/pdf-crypt-aes.pdf", :password<dunno> }, "open encrypted with incorrect password - dies";
p6-pdf/PDF-p6:22: lives-ok { $pdf = PDF.open("t/pdf-crypt-aes.pdf", :password($user-pass)) }, 'open with user password - lives';
p6-pdf/PDF-p6:23: is $pdf.crypt.is-owner, False, 'open with user password - not is-owner';
p6-pdf/PDF-p6:24: is $pdf<Info><Author>, $expected-author, 'open with user password - .Info.Author';
p6-pdf/PDF-p6:25: is $pdf<Root><Pages><Kids>[0]<Contents>.decoded, $expected-contents, 'open with user password - contents';
p6-pdf/PDF-p6:21: dies-ok { $pdf = PDF.open: "t/encrypt.pdf", :password<dunno> }, "open encrypted with incorrect password - dies";
p6-pdf/PDF-p6:23: lives-ok { $pdf = PDF.open("t/pdf-crypt-rc4.pdf", :password($user-pass)) }, 'open with user password - lives';
p6-pdf/PDF-p6:24: is $pdf.crypt.is-owner, False, 'open with user password - not is-owner';
p6-pdf/PDF-p6:25: is $pdf<Info><Author>, $expected-author, 'open with user password - .Info.Author';
p6-pdf/PDF-p6:26: is $pdf<Root><Pages><Kids>[0]<Contents>.decoded, $expected-contents, 'open with user password - contents';
p6-pdf/PDF-p6:28: lives-ok { $pdf = PDF.open("t/pdf-crypt-rc4.pdf", :password($owner-pass)) }, 'open with owner password - lives';
p6-pdf/PDF-p6:29: is $pdf.crypt.is-owner, True, 'open with owner password - is-owner';
p6-pdf/PDF-p6:30: is $pdf<Info><Author>, $expected-author, 'open with owner password - .Info.Author';
p6-pdf/PDF-p6:31: is $pdf<Root><Pages><Kids>[0]<Contents>.decoded, $expected-contents, 'open with owner password - contents';
p6-pdf/PDF-p6:33: dies-ok { $pdf = PDF.open: "t/pdf-crypt-rc4.json", :password<dunno> }, "open encrypted json with incorrect password - dies";
p6-pdf/PDF-p6:35: lives-ok { $pdf = PDF.open("t/pdf-crypt-rc4.json", :password($user-pass)) }, 'open json user password - lives';
perl6-community-modules/uri:55: # the rfc refers to username:password as deprecated
perl6-posix/README.md * getpwnam(Str $username) - Returns an anonymous class containing the broken-out fields of the record in the password database (e.g., th…
perl6-posix/README.md * getgrnam(Str $group) - Returns an anonymous class containing the broken-out fields of the record in the group database that matches the provided group name. The class has the following accessor methods: name, password, gid, and members.
perl6-posix/README.md * getgrgid(gid_t $gid) - Returns an anonymous class containing the broken-out fields of the record in the group database that matches the provided group id. The class has the following accessor methods: name, password, gid, and members.
perl6/DBIish:74: C<database>, C<user> and C<password>.
perl6/DBIish:81: and using the function C<get-secret> to obtain you password, you can:
perl6/DBIish:83: my $dbh = DBIish.connect('Pg', :database<hierarchy>, :$user, password => get-secret());
perl6/DBIish:135: :database<blerg>, :user<myuser>, :$password);
perl6/DBIish:138: C<host>, C<hostaddr>, C<port>, C<database> (or its alias C<dbname>), C<user>, C<password>,
perl6/DBIish:209: :database<blerg>, :user<myuser>, :$password);
perl6/DBIish:212: :database<blerg>, :user<myuser>, :$password);
perl6/DBIish:218: my $dbh = DBIish.connect('Oracle', database => 'XE', :user<sysadm>, :password('secret'));
perl6/DBIish:13: my $dbh = DBIish.connect("mysql", :database<test>, :user<root>, :password<sa>, :RaiseError);
perl6/DBIish:21: my $dbh = DBIish.connect("Pg", :database<postgres>, :user<postgres>, :password<sa>, :RaiseError);
perl6/DBIish:25: :password<sa>, :RaiseError
perl6/DBIish:83: method connect(:database(:$dbname), :user(:$username), :$password, *%params) {
perl6/DBIish:100: :$password,
perl6/DBIish:335: utf8 $password,
perl6/DBIish:342: method Logon(OCIError :$errh, Int :$mode, :$dbname, :$username, :$password) {
perl6/DBIish:344: OCILogon2(self, $errh, $svch, |buf-sized($username), |buf-sized($password),
perl6/DBIish:70: host hostaddr port dbname user password connect-timeout
perl6/DBIish:23: |%params<host user password database port socket>, 0
perl6/DBIish:185: Str $host, Str $user, Str $password,
perl6/DBIish:47: my $test_password = 'testpass';
perl6/DBIish:76: #EVAL {$dbh= DBI->connect($test_dsn, $test_user, $test_password,
perl6/DBIish:89: DBIish.connect($mdriver, :user($test_user), :password($test_password),
perl6/DBIish:110: $dbh = DBIish.connect( $mdriver, :user($test_user), :password($test_password),
perl6/DBIish:179: # $dbh = DBIish.connect( $test_dsn, $test_user, $test_password,
perl6/DBIish:255: $dbh = DBIish.connect( $mdriver, :user($test_user), :password($test_password),
perl6/DBIish:542: #EVAL {$dbh = DBI->connect($test_dsn, $test_user, $test_password,
perl6/DBIish:636: #EVAL {$dbh= DBI->connect($test_dsn, $test_user, $test_password,
perl6/DBIish:914: use vars qw($table $test_dsn $test_user $test_password);
perl6/DBIish:916: EVAL {$dbh= DBI->connect($test_dsn, $test_user, $test_password,
perl6/DBIish:972: use vars qw($test_dsn $test_user $test_password);
perl6/DBIish:978: EVAL {$dbh= DBI->connect($test_dsn, $test_user, $test_password,
perl6/DBIish:1074: use vars qw($table $test_dsn $test_user $test_password);
perl6/DBIish:1079: EVAL {$dbh= DBI->connect($test_dsn, $test_user, $test_password,
perl6/DBIish:1127: use vars qw($table $test_dsn $test_user $test_password);
perl6/DBIish:1132: EVAL {$dbh= DBI->connect($test_dsn, $test_user, $test_password,
perl6/DBIish:1220: use vars qw($test_dsn $test_user $test_password);
perl6/DBIish:1224: EVAL {$dbh = DBI->connect($test_dsn, $test_user, $test_password,
perl6/DBIish:1262: use vars qw($table $test_dsn $test_user $test_password);
perl6/DBIish:1269: EVAL {$dbh= DBI->connect($test_dsn, $test_user, $test_password,
perl6/DBIish:1337: use vars qw($table $test_dsn $test_user $test_password);
perl6/DBIish:1340: EVAL {$dbh= DBI->connect($test_dsn, $test_user, $test_password,
perl6/DBIish:1408: use vars qw($table $test_dsn $test_user $test_password);
perl6/DBIish:1413: EVAL {$dbh= DBI->connect($test_dsn, $test_user, $test_password,
perl6/DBIish:1463: use vars qw($table $test_dsn $test_user $test_password);
perl6/DBIish:1468: EVAL {$dbh= DBI->connect($test_dsn, $test_user, $test_password,
perl6/DBIish:1555: use vars qw($table $test_dsn $test_user $test_password $mdriver);
perl6/DBIish:1563: EVAL {$dbh= DBI->connect($test_dsn, $test_user, $test_password,
perl6/DBIish:1616: use vars qw($test_dsn $test_user $test_password $table);
perl6/DBIish:1619: EVAL {$dbh= DBI->connect($test_dsn, $test_user, $test_password,
perl6/DBIish:1691: use vars qw($got_warning $test_dsn $test_user $test_password $table);
perl6/DBIish:1694: EVAL {$dbh= DBI->connect($test_dsn, $test_user, $test_password,
perl6/DBIish:1779: ok ($dbh = DBI->connect($test_dsn, $test_user, $test_password));
perl6/DBIish:1811: ok ($dbh = DBI->connect($test_dsn, $test_user, $test_password));
perl6/DBIish:1859: use vars qw($test_dsn $test_user $test_password $table);
perl6/DBIish:1862: EVAL {$dbh= DBI->connect($test_dsn, $test_user, $test_password,
perl6/DBIish:1945: use vars qw($table $test_dsn $test_user $test_password);
perl6/DBIish:1951: EVAL {$dbh= DBI->connect($test_dsn, $test_user, $test_password,
perl6/DBIish:2041: use vars qw($table $test_dsn $test_user $test_password);
perl6/DBIish:2063: EVAL {$dbh= DBI->connect($test_dsn, $test_user, $test_password,
perl6/DBIish:2103: EVAL {$dbh2 = DBI->connect($test_dsn, $test_user, $test_password,
perl6/DBIish:2248: use vars qw($table $test_dsn $test_user $test_password);
perl6/DBIish:2256: EVAL {$dbh= DBI->connect($test_dsn, $test_user, $test_password,
perl6/DBIish:2329: use vars qw($table $test_dsn $test_user $test_password);
perl6/DBIish:2339: EVAL {$dbh= DBI->connect($test_dsn, $test_user, $test_password,
perl6/DBIish:2392: my $dbh2 = DBI->connect($test_dsn, $test_user, $test_password,
perl6/DBIish:2450: use vars qw($test_dsn $test_user $test_password);
perl6/DBIish:2453: EVAL {$dbh= DBI->connect( $test_dsn, $test_user, $test_password);};
perl6/DBIish:2482: $dbh = DBI->connect( $test_dsn, $test_user, $test_password,
perl6/DBIish:2495: use vars qw($table $test_dsn $test_user $test_password);
perl6/DBIish:2505: EVAL {$dbh = DBI->connect($test_dsn, $test_user, $test_password,
perl6/DBIish:2556: use vars qw($table $test_dsn $test_user $test_password);
perl6/DBIish:2559: EVAL {$dbh= DBI->connect($test_dsn, $test_user, $test_password,
perl6/DBIish:2629: use vars qw($table $test_dsn $test_user $test_password);
perl6/DBIish:2632: EVAL {$dbh = DBI->connect($test_dsn, $test_user, $test_password,
perl6/DBIish:2652: ok ($dbh = DBI->connect($test_dsn, $test_user, $test_password,
perl6/DBIish:2758: use vars qw($table $test_dsn $test_user $test_password);
perl6/DBIish:2763: EVAL {$dbh= DBI->connect($test_dsn, $test_user, $test_password,
perl6/DBIish:2794: use vars qw($table $mdriver $dbdriver $childPid $test_dsn $test_user $test_password);
perl6/DBIish:2831: $::test_password = $::test_password || $ENV{'DBI_PASS'} || '';
perl6/DBIish:3145: 'testpassword' => '',
perl6/DBIish:3152: $::test_password = $opt->{'testpassword'};
perl6/DBIish:10: :password<testpass>,
perl6/DBIish:21: password 'testpass', all this can be create with:
perl6/DBIish:7: my %con-parms = :database<dbdishtest>, :user<testuser>, :password<testpass>;
perl6/DBIish:7: my %con-parms = :database<dbdishtest>, :user<testuser>, :password<testpass>;
perl6/DBIish:10: password => 'Testpass',
perl6/DBIish:8: %con-parms = :database<XE>, :username<TESTUSER>, :password<Testpass>;
perl6/DBIish:7: my %con-parms = :database<XE>, :username<TESTUSER>, :password<Testpass>;
perl6/Perl6-MIME-Base64:37: is $mime.encode_base64("username:thisisnotmypassword"), 'dXNlcm5hbWU6dGhpc2lzbm90bXlwYXNzd29yZA==', 'Encoding "username:thisisnotmypassword"';
perl6/Perl6-MIME-Base64:38: is $mime.decode_base64("dXNlcm5hbWU6dGhpc2lzbm90bXlwYXNzd29yZA=="), 'username:thisisnotmypassword', 'Decoding "username:thisisnotmypassword"';
perl6/doc:532: UPDATE mysql.user SET password=password('sa') WHERE user = 'root';
perl6/doc:980: [passwords]
perl6/doc:981: jack=password1
perl6/doc:1000: # OUTPUT: «("passwords" => {"jack" => "password1", "joy" => "muchmoresecure123"},
perl6/doc:1548: [passwords]
perl6/doc:1549: jack = password1
perl6/doc:2: !function(a,b){"use strict";"object"==typeof module&&"object"==typeof module.exports?module.exports=a.document?b(a,!0):function(a){if(!a.document)thr…
perl6/doc:4: void 0!==c?null===c?void r.removeAttr(a,b):e&&"set"in e&&void 0!==(d=e.set(a,c,b))?d:(a.setAttribute(b,c+""),c):e&&"get"in e&&null!==(d=e.get(a,b))?d…
perl6/perl6-lwp-simple:69: my $pass = $auth<password>;
perl6/perl6-lwp-simple:376: password => uri_unescape($user_info.split(':')[1] || '')
perl6/perl6-lwp-simple:27: is(@url[4]<password>, 'Camelia', 'Basic auth info extracted correctly: pass');
ppentchev/perl6-Test-Deeply-Relaxed:22: is-deeply-relaxed {:a(42), :password('mellon')}, {password => 'mellon', a => 42}, 'non-empty hash - same';
ppentchev/perl6-Test-Deeply-Relaxed:23: isnt-deeply-relaxed {}, {:password('mellon')}, 'empty and non-empty hash - different';
retupmoca/P6-Net-AMQP:12: has $.password = 'guest';
retupmoca/P6-Net-AMQP:61: "\0"~$.login~"\0"~$.password,
retupmoca/P6-Net-POP3:14: $pop.apop-login("username", "password");
retupmoca/P6-Net-POP3:17: $pop.pass("password");
retupmoca/P6-Net-POP3:28: $pop.auth("username", "password"); # tries apop, then falls back to user/pass
retupmoca/P6-Net-POP3:57: - `auth($username, $password)`
retupmoca/P6-Net-POP3:50: method auth($username, $password) {
retupmoca/P6-Net-POP3:53: $response = $.raw.apop-login($username, $password);
retupmoca/P6-Net-POP3:60: $response = $.raw.pass($password);
retupmoca/P6-Net-SMTP:23: $client.auth($username, $password);
retupmoca/P6-Net-SMTP:68: - `auth($username, $password, :@methods, :@disallow, :$force)`
retupmoca/P6-Net-SMTP:70: Authenticates with the SMTP server with the given $username and $password.
retupmoca/P6-Net-SMTP:131: - `auth-login($username, $password)`
retupmoca/P6-Net-SMTP:132: - `auth-plain($username, $password)`
retupmoca/P6-Net-SMTP:80: method auth-login($username, $password) {
retupmoca/P6-Net-SMTP:84: my $encoded = MIME::Base64.encode-str($password);
retupmoca/P6-Net-SMTP:91: method auth-plain($username, $password) {
retupmoca/P6-Net-SMTP:92: my $encoded = MIME::Base64.encode-str("$username\0$username\0$password");
retupmoca/P6-Net-SMTP:96: method auth-cram-md5($username, $password) {
retupmoca/P6-Net-SMTP:104: my $encoded = MIME::Base64.encode-str($username ~ " " ~ hmac-hex($password, $data, &md5));
retupmoca/P6-Net-SMTP:106: method auth($username, $password, :$methods is copy, :$disallow, :$force) {
retupmoca/P6-Net-SMTP:122: when "CRAM-MD5" { $response = $.smtp-raw.auth-cram-md5($username, $password); }
retupmoca/P6-Net-SMTP:123: when "PLAIN" { $response = $.smtp-raw.auth-plain($username, $password); }
retupmoca/P6-Net-SMTP:124: when "LOGIN" { $response = $.smtp-raw.auth-login($username, $password); }
retupmoca/P6-Net-SMTP:50: ok $client.auth('user@example.com', 'password', :methods("CRAM-MD5")), 'CRAM-MD5 auth';
salortiz/DBDish-ODBC:8: MySQL => { :uid<testuser>, :password<testpass> },
samcns/uzu:19: <input type="password" placeholder="Password" class="form-control">
samcns/uzu:35: <input type="password" placeholder="Password" class="form-control">
scovit/perl6-IRC-Async:79: password => (Str),
scovit/perl6-IRC-Async:10: has Str $.password;
scovit/perl6-IRC-Async:44: push @connect-messages, $.print("PASS $!password\n") if $!password.defined;
scriptkitties/p6-mpd-client:25: sub mpd-password (
scriptkitties/p6-mpd-client:26: Str $password,
scriptkitties/p6-mpd-client:30: mpd-response-ok(mpd-send("password", $password, $socket));
sergot/http-useragent:67: has $.auth_password;
sergot/http-useragent:120: method auth(Str $login, Str $password) {
sergot/http-useragent:122: $!auth_password = $password;
sergot/http-useragent:423: $request.field(Authorization => basic-auth-token($!auth_login,$!auth_password));
sergot/http-useragent:428: $!auth_login.defined && $!auth_password.defined;
sergot/http-useragent:526: method auth(HTTP::UserAgent:, Str $login, Str $password)
sergot/http-useragent:528: Sets username and password needed to HTTP Auth.
sergot/http-useragent:14: is $ua.auth_password, 'TEST', "password got set okay";
sillymoose/Software-License:355: source code form), and must require no special password or key for
skaji/perl6-CPAN-Uploader-Tiny:9: has $.password;
skaji/perl6-CPAN-Uploader-Tiny:12: submethod BUILD(:$!url, :$!user, :$!password, :$!agent) {
skaji/perl6-CPAN-Uploader-Tiny:23: self.new(user => %config<user>, password => %config<password>);
skaji/perl6-CPAN-Uploader-Tiny:47: %config<password> or die "missing password in $file";
skaji/perl6-CPAN-Uploader-Tiny:63: my $url = $!url.subst('//', "//{$.user}:{$.password}@");
skinkade/p6-Crypt-Bcrypt:7: "description" : "Easy bcrypt password hashing",
skinkade/p6-Crypt-Bcrypt:4: Easy `bcrypt` password hashing in Perl6.
skinkade/p6-Crypt-Bcrypt:9: Password hashing and verification are one function each, and utilize a
skinkade/p6-Crypt-Bcrypt:14: > my $hash = bcrypt-hash("password")
skinkade/p6-Crypt-Bcrypt:17: > bcrypt-match("password", $hash)
skinkade/p6-Crypt-Bcrypt:23: > bcrypt-hash("password", :rounds(15))
skinkade/p6-Crypt-Bcrypt:9: Unix Seventh Edition Manual, Volume 2: the password scheme (1978):
skinkade/p6-Crypt-Bcrypt:11: http://plan9.bell-labs.com/7thEdMan/vol2/password
skinkade/p6-Crypt-Bcrypt:14: password shadowing scheme. This includes a PAM module which
skinkade/p6-Crypt-Bcrypt:15: supersedes pam_unix and uses the password hashing framework provided
skinkade/p6-Crypt-Bcrypt:16: with crypt_blowfish when setting new passwords.
skinkade/p6-Crypt-Bcrypt:20: pam_passwdqc, a password strength checking and policy enforcement
skinkade/p6-Crypt-Bcrypt:21: module for PAM-aware password changing programs:
skinkade/p6-Crypt-Bcrypt:25: John the Ripper password cracker:
skinkade/p6-Crypt-Bcrypt:21: The numbers for password cracking are 2 to 10% higher than those for
skinkade/p6-Crypt-Bcrypt:1: This is an implementation of a password hashing method, provided via the
skinkade/p6-Crypt-Bcrypt:15: make your system use the new password hashing algorithm. Changes to
skinkade/p6-Crypt-Bcrypt:22: \- password hashing
skinkade/p6-Crypt-Bcrypt:204: can't fail, when both setting new passwords and authenticating against
skinkade/p6-Crypt-Bcrypt:205: existing password hashes.
skinkade/p6-Crypt-Bcrypt:291: user passwords for storage and authentication;
skinkade/p6-Crypt-Bcrypt:294: It is important to understand that password hashing is not a replacement
skinkade/p6-Crypt-Bcrypt:295: for strong passwords.
skinkade/p6-Crypt-Bcrypt:296: It is always possible for an attacker with access to password hashes
skinkade/p6-Crypt-Bcrypt:297: to try guessing candidate passwords against the hashes.
skinkade/p6-Crypt-Bcrypt:298: There are, however, certain properties a password hashing method may have
skinkade/p6-Crypt-Bcrypt:307: The ability to try candidate passwords against multiple hashes at the
skinkade/p6-Crypt-Bcrypt:311: The use of pre-hashed lists of candidate passwords.
skinkade/p6-Crypt-Bcrypt:315: have the same or different passwords without actually having to guess
skinkade/p6-Crypt-Bcrypt:316: one of the passwords.
skinkade/p6-Crypt-Bcrypt:319: candidate passwords.
skinkade/p6-Crypt-Bcrypt:320: Thus, the computational cost of a good password hashing method must be
skinkade/p6-Crypt-Bcrypt:327: candidate password.
skinkade/p6-Crypt-Bcrypt:331: In addition to salts, modern password hashing methods accept a variable
skinkade/p6-Crypt-Bcrypt:355: .B Maximum password length
skinkade/p6-Crypt-Bcrypt:379: Thus, it should not be used for new passwords unless you absolutely have
skinkade/p6-Crypt-Bcrypt:380: to be able to migrate the password hashes to other systems.
skinkade/p6-Crypt-Bcrypt:393: This is Poul-Henning Kamp's MD5-based password hashing method originally
skinkade/p6-Crypt-Bcrypt:415: specific to password cracking only, doesn't have the effective key size
skinkade/p6-Crypt-Bcrypt:416: limitation, and uses 8-bit characters in passwords.
skinkade/p6-Crypt-Bcrypt:430: (versions up to 1.0.4 inclusive) affecting handling of password characters with
skinkade/p6-Crypt-Bcrypt:438: Unfortunately, the behavior of "$2a$" on password characters with the 8th bit
skinkade/p6-Crypt-Bcrypt:440: When generating new password hashes, the "$2b$" or "$2y$" prefix should be used.
skinkade/p6-Crypt-Bcrypt:567: Niels Provos and David Mazieres. A Future-Adaptable Password Scheme.
skinkade/p6-Crypt-Bcrypt:572: Robert Morris and Ken Thompson. Password Security: A Case History.
skinkade/p6-Crypt-Bcrypt:575: http://plan9.bell-labs.com/7thEdMan/vol2/password
skinkade/p6-Crypt-Bcrypt:6: * This code comes from John the Ripper password cracker, with reentrant
skinkade/p6-Crypt-Bcrypt:7: * and crypt(3) interfaces added, but optimizations specific to password
skinkade/p6-Crypt-Bcrypt:32: * some of his ideas. The password hashing algorithm was designed by David
skinkade/p6-Crypt-Bcrypt:558: * While the bug itself affected the majority of passwords containing
skinkade/p6-Crypt-Bcrypt:561: * only a subset of passwords containing the '\xff' character (not even all of
skinkade/p6-Crypt-Bcrypt:562: * those passwords, just some of them). This character is not found in valid
skinkade/p6-Crypt-Bcrypt:568: * We use an approach that tries to minimize side-channel leaks of password
skinkade/p6-Crypt-Bcrypt:570: * of branches or table lookups. (One conditional branch based on password
skinkade/p6-Crypt-Bcrypt:620: * collision between the correctly computed hash for this password and a set of
skinkade/p6-Crypt-Bcrypt:621: * passwords that could be supplied to the buggy algorithm. Our safety measure
skinkade/p6-Crypt-Bcrypt:639: * state that could be directly specified by a password to the buggy algorithm
skinkade/p6-Crypt-Bcrypt:808: * 2. We don't want to leave sensitive data from our actual password hash
skinkade/p6-Crypt-Bcrypt:833: /* Hash the supplied password */
skinkade/p6-Crypt-Bcrypt:45: sub bcrypt-hash(Str $password, int :$rounds = 12) returns Str is export {
skinkade/p6-Crypt-Bcrypt:46: crypt($password, gensalt($rounds));
skinkade/p6-Crypt-Bcrypt:49: sub bcrypt-match(Str $password, Str $hash) returns Bool is export {
skinkade/p6-Crypt-Bcrypt:50: crypt($password, $hash) eq $hash;
skinkade/p6-Crypt-Bcrypt:13: ok bcrypt-match("password", $hash-old), "2a positive check";
skinkade/p6-Crypt-Bcrypt:14: nok bcrypt-match("password1", $hash-old), "2a negative check";
skinkade/p6-Crypt-Bcrypt:16: ok bcrypt-match("password", $hash-new), "2b positive check";
skinkade/p6-Crypt-Bcrypt:17: nok bcrypt-match("password1", $hash-new), "2b negative check";
skinkade/p6-crypt-argon2:6: "description" : "Easy Argon2i password hashing",
skinkade/p6-crypt-argon2:5: Password Hashing Competition. It is both memory- and compute-hard. This module
skinkade/p6-crypt-argon2:12: Password hashing and verification are one function each, and utilze a
skinkade/p6-crypt-argon2:17: > my $hash = argon2-hash("password")
skinkade/p6-crypt-argon2:20: > argon2-verify($hash, "password")
skinkade/p6-crypt-argon2:26: > argon2-hash("password", :t_cost(4), :m_cost(2**18), :parallelism(4), :hashlen(24))
skinkade/p6-crypt-argon2:36: > my ($key, $meta) = argon2-derive-key("password", :hashlen(16))
skinkade/p6-crypt-argon2:39: > argon2-derive-key("password", $meta)
skinkade/p6-crypt-argon2:47: in KiB, and parallelism in thread count. By default, password hashing uses two
skinkade/p6-crypt-argon2:15: * Password read from stdin, instead of being an argument
skinkade/p6-crypt-argon2:64: /* Minimum and maximum password length in bytes */
skinkade/p6-crypt-argon2:80: #define ARGON2_FLAG_CLEAR_PASSWORD (UINT32_C(1) << 0)
skinkade/p6-crypt-argon2:156: * password and its length,
skinkade/p6-crypt-argon2:165: * Also, three flags indicate whether to erase password, secret as soon as they
skinkade/p6-crypt-argon2:168: * Simplest situation: you have output array out[8], password is stored in
skinkade/p6-crypt-argon2:172: * You want to erase the password, but you're OK with last pass not being
skinkade/p6-crypt-argon2:181: uint8_t *pwd; /* password array */
skinkade/p6-crypt-argon2:182: uint32_t pwdlen; /* password length */
skinkade/p6-crypt-argon2:224: * Hashes a password with Argon2i, producing an encoded hash
skinkade/p6-crypt-argon2:228: * @param pwd Pointer to password
skinkade/p6-crypt-argon2:229: * @param pwdlen Password size in bytes
skinkade/p6-crypt-argon2:247: * Hashes a password with Argon2i, producing a raw hash by allocating memory at
skinkade/p6-crypt-argon2:252: * @param pwd Pointer to password
skinkade/p6-crypt-argon2:253: * @param pwdlen Password size in bytes
skinkade/p6-crypt-argon2:291: * Verifies a password against an encoded string
skinkade/p6-crypt-argon2:294: * @param pwd Pointer to password
skinkade/p6-crypt-argon2:309: * on the password and salt. Only for side-channel-free
skinkade/p6-crypt-argon2:319: * independent on the password and salt. Good for side-channels,
skinkade/p6-crypt-argon2:328: * Verify if a given password is correct for Argon2d hashing
skinkade/p6-crypt-argon2:330: * @param hash The password hash to verify. The length of the hash is
skinkade/p6-crypt-argon2:337: * Verify if a given password is correct for Argon2i hashing
skinkade/p6-crypt-argon2:339: * @param hash The password hash to verify. The length of the hash is
skinkade/p6-crypt-argon2:323: return "Password is too short";
skinkade/p6-crypt-argon2:325: return "Password is too long";
skinkade/p6-crypt-argon2:351: return "Password pointer is NULL, but password length is not 0";
skinkade/p6-crypt-argon2:385: return "The password does not match the supplied hash";
skinkade/p6-crypt-argon2:31: * Benchmarks Argon2 with salt length 16, password length 16, t_cost 1,
skinkade/p6-crypt-argon2:157: clear_memory(instance, context->flags & ARGON2_FLAG_CLEAR_PASSWORD);
skinkade/p6-crypt-argon2:354: /* Validate password length */
skinkade/p6-crypt-argon2:524: if (context->flags & ARGON2_FLAG_CLEAR_PASSWORD) {
skinkade/p6-crypt-argon2:157: * password and secret if needed
skinkade/p6-crypt-argon2:49: printf("Password[%u]: ", context->pwdlen);
skinkade/p6-crypt-argon2:51: if (context->flags & ARGON2_FLAG_CLEAR_PASSWORD) {
skinkade/p6-crypt-argon2:39: printf("\tPassword is read from stdin\n");
skinkade/p6-crypt-argon2:92: fatal("password missing");
skinkade/p6-crypt-argon2:172: /* get password from stdin */
skinkade/p6-crypt-argon2:175: fatal("no password read");
skinkade/p6-crypt-argon2:178: fatal("Provided password longer than supported in command line utility");
skinkade/p6-crypt-argon2:62: hashtest(version, 2, 16, 1, "password", "somesalt",
skinkade/p6-crypt-argon2:67: hashtest(version, 2, 20, 1, "password", "somesalt",
skinkade/p6-crypt-argon2:72: hashtest(version, 2, 18, 1, "password", "somesalt",
skinkade/p6-crypt-argon2:76: hashtest(version, 2, 8, 1, "password", "somesalt",
skinkade/p6-crypt-argon2:80: hashtest(version, 2, 8, 2, "password", "somesalt",
skinkade/p6-crypt-argon2:84: hashtest(version, 1, 16, 1, "password", "somesalt",
skinkade/p6-crypt-argon2:88: hashtest(version, 4, 16, 1, "password", "somesalt",
skinkade/p6-crypt-argon2:92: hashtest(version, 2, 16, 1, "differentpassword", "somesalt",
skinkade/p6-crypt-argon2:96: hashtest(version, 2, 16, 1, "password", "diffsalt",
skinkade/p6-crypt-argon2:106: "password", strlen("password"), Argon2_i);
skinkade/p6-crypt-argon2:113: "password", strlen("password"), Argon2_i);
skinkade/p6-crypt-argon2:117: /* Handle an mismatching hash (the encoded password is "passwore") */
skinkade/p6-crypt-argon2:120: "password", strlen("password"), Argon2_i);
skinkade/p6-crypt-argon2:122: printf("Verify with mismatched password: PASS\n");
skinkade/p6-crypt-argon2:134: hashtest(version, 2, 16, 1, "password", "somesalt",
skinkade/p6-crypt-argon2:139: hashtest(version, 2, 20, 1, "password", "somesalt",
skinkade/p6-crypt-argon2:144: hashtest(version, 2, 18, 1, "password", "somesalt",
skinkade/p6-crypt-argon2:148: hashtest(version, 2, 8, 1, "password", "somesalt",
skinkade/p6-crypt-argon2:152: hashtest(version, 2, 8, 2, "password", "somesalt",
skinkade/p6-crypt-argon2:156: hashtest(version, 1, 16, 1, "password", "somesalt",
skinkade/p6-crypt-argon2:160: hashtest(version, 4, 16, 1, "password", "somesalt",
skinkade/p6-crypt-argon2:164: hashtest(version, 2, 16, 1, "differentpassword", "somesalt",
skinkade/p6-crypt-argon2:168: hashtest(version, 2, 16, 1, "password", "diffsalt",
skinkade/p6-crypt-argon2:178: "password", strlen("password"), Argon2_i);
skinkade/p6-crypt-argon2:185: "password", strlen("password"), Argon2_i);
skinkade/p6-crypt-argon2:189: /* Handle an mismatching hash (the encoded password is "passwore") */
skinkade/p6-crypt-argon2:192: "password", strlen("password"), Argon2_i);
skinkade/p6-crypt-argon2:194: printf("Verify with mismatched password: PASS\n");
skinkade/p6-crypt-argon2:205: ret = argon2_hash(2, 1, 1, "password", strlen("password"),
skinkade/p6-crypt-argon2:211: ret = argon2_hash(2, 1 << 12, 1, NULL, strlen("password"),
skinkade/p6-crypt-argon2:217: ret = argon2_hash(2, 1 << 12, 1, "password", strlen("password"), "s", 1,
skinkade/p6-crypt-argon2:8: my $hash = argon2-hash("password");
skinkade/p6-crypt-argon2:11: ok argon2-verify($hash, "password"), "Verify true new hash";
skinkade/p6-crypt-argon2:12: ok argon2-verify($hash-reference, "password"), "Verify true reference hash";
skinkade/p6-crypt-argon2:14: nok argon2-verify($hash, "password1"), "False-check on new hash";
skinkade/p6-crypt-argon2:15: nok argon2-verify($hash-reference, "password1"), "False-check on reference hash";
skinkade/p6-crypt-argon2:9: my ($key, $meta) = argon2-derive-key("password");
skinkade/p6-crypt-argon2:11: my $test = argon2-derive-key("password", $meta);
spebern/Parser-FreeXL-Native:25: BIFF Password/Crypted: NO, clear data
spebern/Parser-FreeXL-Native:57: BIFF Password/Crypted: NO, clear data
spebern/Parser-FreeXL-Native:220: ret = freexl_get_info (handle, FREEXL_BIFF_PASSWORD, &info);
spebern/Parser-FreeXL-Native:223: fprintf (stderr, "GET-INFO [FREEXL_BIFF_PASSWORD] Error: %d\n", ret);
spebern/Parser-FreeXL-Native:229: printf ("BIFF Password/Crypted: YES, obfuscated (not accessible)\n");
spebern/Parser-FreeXL-Native:232: printf ("BIFF Password/Crypted: NO, clear data\n");
spebern/Parser-FreeXL-Native:235: printf ("BIFF Password/Crypted: UNKNOWN\n");
spebern/Parser-FreeXL-Native:128: /* checking for Password (obfuscated/encrypted) */
spebern/Parser-FreeXL-Native:129: ret = freexl_get_info (handle, FREEXL_BIFF_PASSWORD, &info);
spebern/Parser-FreeXL-Native:132: fprintf (stderr, "GET-INFO [FREEXL_BIFF_PASSWORD] Error: %d\n", ret);
spebern/Parser-FreeXL-Native:141: fprintf (stderr, "Password protected: (not accessible)\n");
spebern/Parser-FreeXL-Native:111: /** BIFF file is password protected */
spebern/Parser-FreeXL-Native:113: /** BIFF file is not password protected */
spebern/Parser-FreeXL-Native:219: /** Information query for BIFF password protection state */
spebern/Parser-FreeXL-Native:220: #define FREEXL_BIFF_PASSWORD 32008
spebern/Parser-FreeXL-Native:448: - FREEXL_BIFF_PASSWORD (returning FREEXL_BIFF_OBFUSCATED or
spebern/Parser-FreeXL-Native:315: as author, password protection, styles, formats, window settings and so on
spebern/Parser-FreeXL-Native:2310: /* PASSWORD marker found */
spebern/Parser-FreeXL-Native:3008: /* PASSWORD marker found */
spebern/Parser-FreeXL-Native:4406: case FREEXL_BIFF_PASSWORD:
spebern/Parser-FreeXL-Native:135: ret = freexl_get_info(handle, FREEXL_BIFF_PASSWORD, &info);
spebern/Parser-FreeXL-Native:137: fprintf(stderr, "GET_INFO ERROR for BIFF password mode: %d\n", ret);
spebern/Parser-FreeXL-Native:141: fprintf(stderr, "Unexpected BIFF password mode: %d\n", info);
spebern/Parser-FreeXL-Native:135: ret = freexl_get_info(handle, FREEXL_BIFF_PASSWORD, &info);
spebern/Parser-FreeXL-Native:137: fprintf(stderr, "GET_INFO ERROR for BIFF password mode: %d\n", ret);
spebern/Parser-FreeXL-Native:141: fprintf(stderr, "Unexpected BIFF password mode: %d\n", info);
spebern/Parser-FreeXL-Native:135: ret = freexl_get_info(handle, FREEXL_BIFF_PASSWORD, &info);
spebern/Parser-FreeXL-Native:137: fprintf(stderr, "GET_INFO ERROR for BIFF password mode: %d\n", ret);
spebern/Parser-FreeXL-Native:141: fprintf(stderr, "Unexpected BIFF password mode: %d\n", info);
spebern/Parser-FreeXL-Native:135: ret = freexl_get_info(handle, FREEXL_BIFF_PASSWORD, &info);
spebern/Parser-FreeXL-Native:137: fprintf(stderr, "GET_INFO ERROR for BIFF password mode: %d\n", ret);
spebern/Parser-FreeXL-Native:141: fprintf(stderr, "Unexpected BIFF password mode: %d\n", info);
spebern/Parser-FreeXL-Native:135: ret = freexl_get_info(handle, FREEXL_BIFF_PASSWORD, &info);
spebern/Parser-FreeXL-Native:137: fprintf(stderr, "GET_INFO ERROR for BIFF password mode: %d\n", ret);
spebern/Parser-FreeXL-Native:141: fprintf(stderr, "Unexpected BIFF password mode: %d\n", info);
spebern/Parser-FreeXL-Native:135: ret = freexl_get_info(handle, FREEXL_BIFF_PASSWORD, &info);
spebern/Parser-FreeXL-Native:137: fprintf(stderr, "GET_INFO ERROR for BIFF password mode: %d\n", ret);
spebern/Parser-FreeXL-Native:141: fprintf(stderr, "Unexpected BIFF password mode: %d\n", info);
spebern/Parser-FreeXL-Native:135: ret = freexl_get_info(handle, FREEXL_BIFF_PASSWORD, &info);
spebern/Parser-FreeXL-Native:137: fprintf(stderr, "GET_INFO ERROR for BIFF password mode: %d\n", ret);
spebern/Parser-FreeXL-Native:141: fprintf(stderr, "Unexpected BIFF password mode: %d\n", info);
spebern/Parser-FreeXL-Native:135: ret = freexl_get_info(handle, FREEXL_BIFF_PASSWORD, &info);
spebern/Parser-FreeXL-Native:137: fprintf(stderr, "GET_INFO ERROR for BIFF password mode: %d\n", ret);
spebern/Parser-FreeXL-Native:141: fprintf(stderr, "Unexpected BIFF password mode: %d\n", info);
spebern/Parser-FreeXL-Native:135: ret = freexl_get_info(handle, FREEXL_BIFF_PASSWORD, &info);
spebern/Parser-FreeXL-Native:137: fprintf(stderr, "GET_INFO ERROR for BIFF password mode: %d\n", ret);
spebern/Parser-FreeXL-Native:141: fprintf(stderr, "Unexpected BIFF password mode: %d\n", info);
sufrostico/perl6-snowball:340: source code form), and must require no special password or key for
supernovus/perl6-http-client:24: has $!pass; ## Password, if needed, for Authentication.
supernovus/perl6-http-client:52: token pass { [\w|'-'|'+'|'%']+ } ## Fairly simple passwords only too.
supernovus/perl6-http-client:59: ## Encode a username and password into Base64 for Basic Auth.
supernovus/perl6-web-app-mvc:66: "password" : "myapppass"
szabgab/Perl6-Maven:777: input[type="password"],
szabgab/Perl6-Maven:811: input[type="password"],
szabgab/Perl6-Maven:842: input[type="password"]:focus,
szabgab/Perl6-Maven:9: */article,aside,details,figcaption,figure,footer,header,hgroup,nav,section{display:block}audio,canvas,video{display:inline-block;*display:inline;*zo…
szabgab/Perl6-Maven:3: a){var b=F.exec(a);b&&(b[1]=(b[1]||"").toLowerCase(),b[3]=b[3]&&new RegExp("(?:^|\\s)"+b[3]+"(?:\\s|$)"));return b},H=function(a,b){var c=a.attribute…
szabgab/Perl6-Maven:4: .clean(arguments);a.push.apply(a,this.toArray());return this.pushStack(a,"before",arguments)}},after:function(){if(this[0]&&this[0].parentNode)return…
tadzik/Grammar-BNF:223: login = "LOGIN" SP userid SP password
tadzik/Grammar-BNF:243: password = astring
tadzik/Grammar-BNF:317: throws-like { $rfc4466g.parse('LOGIN MyUsername MyPassword', :rule<login>) },
titsuki/p6-App-AizuOnlineJudge:29: password => self.get-password,
titsuki/p6-App-AizuOnlineJudge:30: password => self.get-password,
titsuki/p6-App-AizuOnlineJudge:4: method get-password() returns Str {
titsuki/p6-App-AizuOnlineJudge:5: shell "stty -echo"; my $password = prompt("password: "); "".say; shell "stty echo";
titsuki/p6-App-AizuOnlineJudge:6: return $password;
titsuki/p6-App-AizuOnlineJudge:15: $*IN = class { method get() { "fakepassword" }; }
titsuki/p6-App-AizuOnlineJudge:22: $*IN = class { method get() { "fakepassword" }; }
titsuki/p6-App-AizuOnlineJudge:40: method content() { "<font color=#ff000F><b>\nUserID or Password is Wrong.\n</b></font>\n<result><succeeded>false</succeeded><message>Invalid user</message></result>\n" }
titsuki/p6-App-AizuOnlineJudge:61: $*IN = class { method get() { "fakepassword" }; }
titsuki/p6-App-AizuOnlineJudge:74: $*IN = class { method get() { "fakepassword" }; }
titsuki/p6-Terminal-Readsecret:9: "description" : "A perl6 binding of readsecret ( https://github.com/dmeranda/readsecret ) for reading secrets or passwords from a command line secretly (not being displayed)",
titsuki/p6-Terminal-Readsecret:6: Terminal::Readsecret - A perl6 binding of readsecret ( https://github.com/dmeranda/readsecret ) for reading secrets or passwords from a command line secretly (not being displayed)
titsuki/p6-Terminal-Readsecret:15: my $password = getsecret("password:" );
titsuki/p6-Terminal-Readsecret:16: say "your password is: " ~ $password;
titsuki/p6-Terminal-Readsecret:23: my $password = getsecret("password:", $timeout);
titsuki/p6-Terminal-Readsecret:24: say "your password is: " ~ $password;
titsuki/p6-Terminal-Readsecret:29: Terminal::Readsecret is a perl6 binding of readsecret ( [https://github.com/dmeranda/readsecret](https://github.com/dmeranda/readsecret) ). Readsecre…
titsuki/p6-Terminal-Readsecret:40: Reads secrets or passwords from a command line and returns its input.
titsuki/p6-Terminal-Readsecret:5: my $password = getsecret("password:" );
titsuki/p6-Terminal-Readsecret:6: say "your password is: " ~ $password;
titsuki/p6-Terminal-Readsecret:6: my $password = getsecret("password:", $timeout);
titsuki/p6-Terminal-Readsecret:7: say "your password is: " ~ $password;
titsuki/p6-Terminal-Readsecret:78: Terminal::Readsecret - A perl6 binding of readsecret ( https://github.com/dmeranda/readsecret ) for reading secrets or passwords from a command line secretly (not being displayed)
titsuki/p6-Terminal-Readsecret:85: my $password = getsecret("password:" );
titsuki/p6-Terminal-Readsecret:86: say "your password is: " ~ $password;
titsuki/p6-Terminal-Readsecret:92: my $password = getsecret("password:", $timeout);
titsuki/p6-Terminal-Readsecret:93: say "your password is: " ~ $password;
titsuki/p6-Terminal-Readsecret:98: Readsecret is a simple self-contained C (or C++) library intended to be used on Unix and Unix-like operating systems that need to read a password or other textual secret typed in by the user while in a text-mode environment, such as from a console or shell.
titsuki/p6-Terminal-Readsecret:108: Reads secrets or passwords from a command line and returns its input.
titsuki/p6-Terminal-Readsecret:3: ** Securely read a password or text secret from a command line (tty device).
titsuki/p6-Terminal-Readsecret:3: ** Securely read a password or text secret from a command line (tty device).
titsuki/p6-Terminal-Readsecret:70: /* rsecret_overwrite_buffer() - securely overwrite a password or other
titsuki/p6-Terminal-Readsecret:7: throws-like { getsecret("password", $timeout) }, Exception, message => 'timeout waiting for user';
tokuhirom/p6-Crust:79: my sub authen_cb($username, $password, %env) {
tokuhirom/p6-Crust:80: return $username eq 'admin' && $password eq 's3cr3t';
tokuhirom/p6-Crust:98: A callback function that takes username, password and PSGI environment
tokuhirom/p6-Crust:102: method that takes username and password and returns boolean.
tony-o/perl6-db-orm-quicky:41: password => 'top secret',
tony-o/perl6-db-orm-quicky:118: $user.set('password', 'user1-pass!');
tony-o/perl6-db-orm-quicky:16: password => '',
tony-o/perl6-db-orm-quicky:28: $newrow.set('password' => 'tony');
tony-o/perl6-db-orm-quicky:16: password => '',
tony-o/perl6-db-orm-quicky:28: $newrow.set('password' => 'tony');
tony-o/perl6-db-orm-quicky:24: $newrow.set('password' => 'tony');
tony-o/perl6-db-orm-quicky:38: $newrow.set('password' => 'tony');
tony-o/perl6-db-orm-quicky:48: password => ( '-like' => '%on%' ),
tony-o/perl6-db-orm-quicky:28: my @expected = |qw<DBORMID joined uid username password>, 'full name';
tony-o/perl6-db-orm-quicky:31: password => 'tony',
tony-o/perl6-db-orm-quicky:45: $newrow.set('password' => 'tony');
ugexe/Perl6-Base64:15: is encode-base64("username:thisisnotmypassword", :str), 'dXNlcm5hbWU6dGhpc2lzbm90bXlwYXNzd29yZA==', 'Encoding "username:thisisnotmypassword"';
ugexe/Perl6-Base64:36: is decode-base64("dXNlcm5hbWU6dGhpc2lzbm90bXlwYXNzd29yZA==", :bin).decode, "username:thisisnotmypassword", 'decoding "username:thisisnotmypassword"';
viklund/november:1: # Password generation is a manual process right now; run bin/generate-password.pl USER PASS
viklund/november:5: 'password' => '47c96e61cbcb31e648b1987107117ca4f524658460b955e290675789466fcd1a',
viklund/november:210: my $password = $.cgi.params<password>;
viklund/november:215: if !defined $password || $password eq '' {
viklund/november:216: push @errors, 'Please provide a password.';
viklund/november:219: if $password && $password.chars < 6 {
viklund/november:221: ~ 'your password.';
viklund/november:224: if $password & $passagain && $password ne $passagain {
viklund/november:225: push @errors, 'The password and confirmation must match.';
viklund/november:237: my $phash = sha256((sha256($user_name.encode).list».fmt("%02x") ~ $password).encode).list».fmt("%02x");
viklund/november:245: my $password = $.cgi.params<password>;
viklund/november:250: my $hashed = sha256((sha256($user_name.encode).list».fmt("%02x") ~ $password).encode).list».fmt("%02x");
viklund/november:252: and $hashed eq %users{$user_name}<password> {
viklund/november:687: my $password = $cgi->param('password');
viklund/november:691: if ( md5_base64(md5_base64($user_name).$password)
viklund/november:692: eq $users{$user_name}->{password} ) {
viklund/november:3: 'password' => 'hdm24HFlfrBgIX3bTsVLIQ'
viklund/november:6: 'password' => '3l9drfMnROgPQTNicdGFQg'
viklund/november:9: 'password' => 'yG7xslKNZt59hpwVBkWrFQ',
viklund/november:21: <p>Password: <input name="password" type="password" /></p>
viklund/november:17: <p>Password: <input name="password" type="password" /></p>
viklund/november:17: <p>Password: <input name="password" type="password" /></p>
viklund/november:15: <p>Password: <input name="password" type="password" /></p>
viklund/november:18: <p>Password: <input name="password" type="password" /></p>
viklund/november:18: <p>Password: <input name="password" type="password" /></p>
viklund/november:19: <p>Password again: <input name="passagain" type="passagain" /></p>
viklund/november:431: \f0\fs24\lang1033\langfe1033\langnp1033\insrsid4985751\charrsid4985751 :\line }{\rtlch\fcs1 \af2\afs24 \ltrch\fcs0 \f2\fs24\lang1033\langfe1033\langnp1033\insrsid4985751\charrsid4985751 if (defined %users\{$user_name\} \line and $password eq %users\{
viklund/november:444: \f2\fs24\lang1033\langfe1033\langnp1033\insrsid9450395\charrsid9450395 password}{\rtlch\fcs1 \af2\afs24 \ltrch\fcs0 \f2\fs24\insrsid9450395\charrsid9450395 ' => '}{\rtlch\fcs1 \af2\afs24 \ltrch\fcs0
viklund/november:452: \f2\fs24\lang1033\langfe1033\langnp1033\insrsid9450395\charrsid9450395 password}{\rtlch\fcs1 \af2\afs24 \ltrch\fcs0 \f2\fs24\insrsid9450395\charrsid9450395 ' => '3}{\rtlch\fcs1 \af2\afs24 \ltrch\fcs0
zoffixznet/perl6-Config-From:29: say "$user\'s password is $pass and they belong to @groups[]";
zoffixznet/perl6-Config-From:30: # Prints: zoffix's password is s3cret and they belong to foo, bar, ber
zoffixznet/perl6-Config-From:7: say "$user\'s password is $pass and they belong to @groups[]";
zoffixznet/perl6-IRC-Client-Plugin-HNY:12: :password('secret.txt'.IO.slurp.trim)
zoffixznet/perl6-IRC-Client:23: - Add support for channel passwords (#18)
zoffixznet/perl6-IRC-Client:67: - [`.password`](#password)
zoffixznet/perl6-IRC-Client:87: - [`:password`](#password-1)
zoffixznet/perl6-IRC-Client:448: server. Pairs represent channels with channel passwords, where the key is
zoffixznet/perl6-IRC-Client:449: the channel and the value is its password.
zoffixznet/perl6-IRC-Client:468: #### `.password`
zoffixznet/perl6-IRC-Client:470: The password of the server.
zoffixznet/perl6-IRC-Client:548: :password<s3cret>
zoffixznet/perl6-IRC-Client:576: Pairs represent channels with channel passwords, where the key is
zoffixznet/perl6-IRC-Client:577: the channel and the value is its password.
zoffixznet/perl6-IRC-Client:638: ##### `:password`
zoffixznet/perl6-IRC-Client:640: The server password to use. On some networks (like Freenode), the server
zoffixznet/perl6-IRC-Client:641: password also functions as NickServ's password.
zoffixznet/perl6-IRC-Client:662: `:host`, `:port`, `:password`, `:channels`, `:nick`, `:username`,
zoffixznet/perl6-IRC-Client:41: Str :$password,
zoffixznet/perl6-IRC-Client:54: my %all-conf = :$port, :$password, :$host, :$nick, :$alias,
zoffixznet/perl6-IRC-Client:67: <host password port username userhost userreal>
zoffixznet/perl6-IRC-Client:190: self!ssay: "PASS $server.password()", :$server
zoffixznet/perl6-IRC-Client:191: if $server.password.defined;
zoffixznet/perl6-IRC-Client:9: has Str $.password;
zoffixznet/perl6-IRC-Client:36: password => 'fishdont',
zoffixznet/perl6-RT-REST-Client:50: You need to go to user preferences and set up your CLI password for your
zoffixznet/perl6-RT-REST-Client:53: and the CLI Password section should be on the right side of the page.
zoffixznet/perl6-RT-REST-Client:75: **Mandatory.** Your RT password. Note that your regular web login likely won't
zoffixznet/perl6-RT-REST-Client:76: work. You need to set up the CLI password. See [LOGIN CREDENTIALs
Created
May 24, 2017 15:41
-
-
Save Whateverable/462a7280c6d48f00b125dfa5ce1756b8 to your computer and use it in GitHub Desktop.
greppable6
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| pa..word |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment