Password generator: Difference between revisions

<!-- or zed, on the other side of the pond. -->

<br><br>

 

=={{header|8086 Assembly}}==

Help is printed when no arguments are given.

 

bits 16

;;; MS-DOS syscalls

lmask: resb 1 ; Mask for random number generation

rnddat: resb 4 ; RNG state

 

=={{header|Action!}}==

BYTE res

 

UNTIL again=0

OD

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Password_generator.png Screenshot from Atari 8-bit computer]

 

=={{header|Ada}}==

with Ada.Strings.Fixed;

with Ada.Command_Line;

end loop;

 

{{out}}

<pre>$ ./mkpw count 8 length 22 safe

 

=={{header|Applesoft BASIC}}==

2 L=8

3 M$=CHR$(13)

900 Q = 1

910 VTAB 23

=={{header|Arturo}}==

 

uppercase: `A`..`Z`

digits: `0`..`9`

loop 1..10 'x [

print generate to :integer first arg

 

{{out}}

 

=={{header|AWK}}==

# syntax: GAWK -f PASSWORD_GENERATOR.AWK [-v mask=x] [-v xt=x]

#

printf("example: %s -v mask=%s -v xt=%s\n",cmd,mask,xt)

}

{{out}}

<pre>

 

=={{header|C}}==

#include <stdio.h>

#include <stdlib.h>

return 0;

}

 

{{out}}

 

=={{header|C sharp|C#}}==

using System.Linq;

 

return new string(password);

}

{{out}}

<pre>PASSGEN -l:12 -c:6

 

=={{header|C++}}==

#include <string>

#include <algorithm>

}

return 0;

{{out}}

<pre>

<b>module.ceylon</b>:

 

module rosetta.passwordgenerator "1.0.0" {

import ceylon.random "1.2.2";

}

 

 

<b>run.ceylon:</b>

 

import ceylon.random {

DefaultRandom,

Character[] filterCharsToExclude(Character[] chars, Character[] charsToExclude)

=> chars.filter((char) => ! charsToExclude.contains(char)).sequence();

 

 

 

=={{header|Clojure}}==

(:require [clojure.set :refer [difference]]

[clojure.tools.cli :refer [parse-opts]])

(if (:help options) (println summary)

(dotimes [n (:count options)]

 

{{out}}

Note that on line 220, the <code>CLR</code> statement is called prior to restarting the program to avoid a <code>?REDIM'D ARRAY ERROR</code> if line 85 should execute. By default, single dimension arrays do not need to be DIMensioned if kept to 11 elements (0 through 10) or less. Line 85 checks for this.

 

2 rem rosetta code

10 g$(1)="abcdefghijklmnopqrstuvwxyz"

610 print "Press any key to begin."

615 get k$:if k$="" then 615

 

{{out}}

 

=={{header|Common Lisp}}==

(defvar *lowercase* '(#\a #\b #\c #\d #\e #\f #\g #\h #\i #\j #\k #\l #\m

#\n #\o #\p #\q #\r #\s #\t #\u #\v #\w #\x #\y #\z))

(loop for x from 1 to count do

(print (generate-password len human-readable)))))

{{out}}

<pre>

 

=={{header|Crystal}}==

 

special_chars = true

break if count <= 0

end

 

{{out}}

 

=={{header|Elixir}}==

@lower Enum.map(?a..?z, &to_string([&1]))

@upper Enum.map(?A..?Z, &to_string([&1]))

end

 

 

{{out}}

=={{header|F_Sharp|F#}}==

===The function===

// A function to generate passwords of a given length. Nigel Galloway: May 2nd., 2018

let N = (set)"qwertyuiopasdfghjklzxcvbnm"

let fN n = not (Set.isEmpty (Set.intersect N n )||Set.isEmpty (Set.intersect I n )||Set.isEmpty (Set.intersect G n )||Set.isEmpty (Set.intersect E n ))

Seq.initInfinite(fun _->(set)(List.init n (fun _->L.[y.Next()%(Array.length L)])))|>Seq.filter fN|>Seq.map(Set.toArray >> System.String)

===A possible use===

Print 5 password of length 8

pWords 8 |> Seq.take 5 |> Seq.iter(printfn "%s")

{{out}}

<pre>

=={{header|Factor}}==

{{works with|Factor|0.99 2020-01-23}}

kernel math math.parser multiline namespaces peg.ebnf

prettyprint random sequences ;

[ parse-args gen-pwds ] [ 2drop usage print ] recover ;

 

{{out}}

<pre>

 

=={{header|FreeBASIC}}==

charS(1) = "0123456789"

charS(2) = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"

Wend

Sleep

{{out}}

<pre>------ Password Generator ------

</pre>

 

=={{header|Gambas}}==

'''[https:c/gambas-playground.proko.eu/?gist=0ef1242c761d8a39297fb913fc6a56c0 Click this link to run this code]'''

 

' INSTRUCTIONS

Print sPassword 'Print the password list

 

Output:

<pre>

 

=={{header|Go}}==

package main

 

}

}

{{out}}

<pre>

The function <code>password</code> for given length and a list of char sets which should be included, generates random password.

 

import Control.Monad.Random

import Data.List

x <- uniform lst

xs <- shuffle (delete x lst)

 

For example:

User interface (uses a powerful and easy-to-use command-line [https://hackage.haskell.org/package/options-1.2.1.1/docs/Options.html option parser]).

 

 

data Opts = Opts { optLength :: Int

, "!\"#$%&'()*+,-./:;<=>?@[]^_{|}~" ]

 

 

{{Out}}

Implementation:

 

chr=: a.&i.

 

y must be at least 4 because

passwords must contain four different kinds of characters.

 

Example use (from J command line):

 

[x] pwgen y - generates passwords of length y

optional x says how many to generate (if you want more than 1)

Oo?|2oc4yi

9V9[EJ:Txs

 

=={{header|Java}}==

{{works with|Java|7}}

 

public class PasswordGenerator {

return sb.toString();

}

 

<pre>7V;m

 

=={{header|JavaScript}}==

return this.split('').sort(() => Math.random() - .5).join('');

}

console.log( createPwd( {len: 20, num: 2}) );

console.log( createPwd( {len: 20, num: 2, noSims: false}) );

{{out}}<pre>

> Q^g"7

</pre>

 

=={{header|Julia}}==

{{works with|Julia|0.6}}

 

if len < 4; error("length must be at least 4") end

# Definitions

end

 

 

{{out}}

 

=={{header|Kotlin}}==

 

import java.util.Random

generatePasswords(pwdLen!!, pwdNum!!, toConsole, toFile!!)

 

Sample input and output:

 

=={{header|Lua}}==

local index, pw, rnd = 0, ""

local chars = {

os.exit()

end

Command line session:

<pre>>lua pwgen.lua

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

and similar=1 if you want similar characters, 0 if not. True and \

False, should work in place of 1/0 *)

 

=={{header|Nim}}==

 

const Symbols = toSeq("!\"#$%&'()*+,-./:;<=>?@[]^_{|}~")

# Display the passwords.

for pw in passGen(passLength, count, seed, excludeSimilars):

 

{{out}}

=={{header|OCaml}}==

 

let upper = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"

let digit = "0123456789"

for i = 1 to !num do

print_endline (mk_pwd !len !readable)

 

{{out}}

=={{header|ooRexx}}==

{{trans||REXX}}

parse arg L N seed xxx dbg /*obtain optional arguments from the CL*/

casl= 'abcdefghijklmnopqrstuvwxyz' /*define lowercase alphabet. */

¦ dbg Schow count of characters in the 4 groups ¦

+-----------------------------------------------------------------------------+

{{out}}

<pre>D:\>rexx genpwd 12 4 33 , x

 

PARI/GP has a very good builtin random generator.

{

if (len <= 4, print("password too short, minimum len=4"); return(), seed, setrand(seed));

}

 

 

Output: ''passwd()''<pre>34K76+mB</pre>

 

=={{header|Pascal}}==

program passwords (input,output);

 

end.

 

Useage for the output example: passwords --about -h --length=12 --number 12 --exclude

 

=={{header|Perl}}==

Use the module <tt>Math::Random</tt> for marginally better random-ness than the built-in function, but no warranty is expressed or implied, <i>caveat emptor</i>.

use warnings;

use feature 'say';

[--help]

END

{{out}}

<pre>sc3O~3e0

 

=={{header|Phix}}==

<span style="color: #000080;font-style:italic;">--with javascript_semantics -- not quite yet:</span>

<span style="color: #008080;">without</span> <span style="color: #008080;">js</span> <span style="color: #000080;font-style:italic;">-- (VALUECHANGED_CB not yet triggering)</span>

<span style="color: #000000;">main</span><span style="color: #0000FF;">()</span>

{{out}}

With a length of 12 and generating 6 of them

 

=={{header|PicoLisp}}==

 

# Default seed

(rot '(*UppChars *Others *Digits *LowChars))) ) ) ) ) ) ) )

 

Test:

<pre>$ genpw --help

 

=={{header|PowerShell}}==

function New-RandomPassword

{

}

}

New-RandomPassword -Length 12 -Count 4 -ExcludeSimilar

{{Out}}

<pre>

</pre>

Make it Unix-like:

Set-Alias -Name nrp -Value New-RandomPassword -Description "Generates one or more passwords"

 

nrp -l 12 -n 4 -x

{{Out}}

<pre>

=={{header|Prolog}}==

{{works with|SWI-Prolog|7.6.4 or higher}}

:- initialization(main, main).

 

pword_char( upper, C ) :- member( C, "ABCDEFGHIJKLMNOPQRSTUVWXYZ" ).

pword_char( digits, C ) :- member( C, "0123456789" ).

{{out}}

Showing help

 

=={{header|PureBasic}}==

 

Procedure.b CheckPW(pw.s)

~"Blabla blabla bla blablabla."

EndOfHelp:

{{out}}

<pre>Length of the password (n>=4): 10

=={{header|Python}}==

 

 

lowercase = 'abcdefghijklmnopqrstuvwxyz' # same as string.ascii_lowercase

for i in range(qty):

print(new_password(length, readable))

{{output}}

<pre>>>> password_generator(14, 4)

 

=={{header|R}}==

passwords <- function(nl = 8, npw = 1, help = FALSE) {

if (help) return("gives npw passwords with nl characters each")

## Tj@T19L.q1;I*]

## 6M+{)xV?i|1UJ/

 

=={{header|Racket}}==

#lang racket

 

 

(run (len) (cnt) (seed) (readable?))

'''Sample output:'''

<pre>

{{works with|Rakudo|2016.05}}

 

set('a' .. 'z'),

set('A' .. 'Z'),

{$*PROGRAM-NAME} --l=14 --c=5 --x=0O\\\"\\\'1l\\\|I

END

'''Sample output:'''

Using defaults:

 

===functional===

['a' .. 'z'],

['A' .. 'Z'],

Password must have at least one of each: lowercase letter, uppercase letter, digit, punctuation.

END

'''Sample output:'''

 

:::* &nbsp; checking if the hexadecimal literal &nbsp; ('''yyy''') &nbsp; is valid

:::* &nbsp; checking (for instance) if all digits were excluded via the &nbsp; <b>'''xxx'''</b> &nbsp; and/or &nbsp; '''yyy''' &nbsp; option

@L='abcdefghijklmnopqrstuvwxyz'; @U=@L; upper @U /*define lower-, uppercase Latin chars.*/

@#= 0123456789 /* " " string of base ten numerals.*/

║ The default is to use all the (normal) available characters. ║

║ yyy (same as XXX, except the chars are expressed as hexadecimal pairs).║

'''output''' &nbsp; when using the inputs of: &nbsp; <tt> 10 &nbsp; 20 </tt>

<pre>

 

=={{header|Ring}}==

# Project : Password generator

 

end

fclose(fp)

Output:

<pre>

password = u8/Ah8%H

password = c4\Nc2_J

</pre>

 

=={{header|Ruby}}==

("A".."Z").to_a,

("0".."9").to_a,

 

puts generate_pwd(8,3)

 

=={{header|Run BASIC}}==

a$(2) = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"

a$(3) = "abcdefghijklmnopqrstuvwxyz"

goto [main]

[exit] ' get outta here

<pre>Generate 10 passwords with 7 characters

#1 69+;Jj8

#10 f0Qho:5</pre>

=={{header|Rust}}==

use rand::distributions::Alphanumeric;

use rand::prelude::IteratorRandom;

}

}

{{out}}

<pre>

=={{header|Scala}}==

Using SBT to run rather than a shell script or executable jar:

 

def newPassword( salt:String = "", length:Int = 13, strong:Boolean = true ) = {

 

if( count > 1 ) println

{{output}}

> sbt "run --help"

 

=={{header|Seed7}}==

 

const func string: generate (in integer: length) is func

end if;

end if;

 

{{out}}

Swift uses arc4random() to generate fast and high quality random numbers. However the usage of a user defined seed is not possible within arc4random(). To fulfill the requirements this code uses the C functions srand() and rand() that are integrated into the Swift file via an Bridging-Header.<br><br>

'''C file to generate random numbers'''

#include <time.h>

 

int getRand(const int upperBound){

return rand() % upperBound;

 

'''Bridging-Header to include C file into Swift'''

 

'''Swift file'''

import GameplayKit // for use of inbuilt Fisher-Yates-Shuffle

 

for i in 1...count {

print("\(i).\t\(generatePassword(length:length,exclude:xclude))")

{{out}}

<pre>$ PasswordGenerator -h

 

=={{header|VBA}}==

Option Explicit

Sub Main()

End If

z = temp

{{out}}

Function Gp :

{{libheader|Wren-ioutil}}

{{libheader|Wren-fmt}}

import "os" for Process

 

}

 

 

{{out}}

 

The generated passwords have been written to the file pwds.txt

</pre>

 

=={{header|zkl}}==

Put the following code into a file (such as pwdg.zkl):

 

argh:=Utils.Argh(

pwd:=T(g1,g2,g3,g4).pump(Data,rnd); // 1 from each of these into a Data

pwd.extend(fill()).shuffle().text.println();

This is a command line program so output can be redirected.

{{out}}