DEV Community: Kidus

How to Make a Password Generator Bot - Part 2 [Golang/go-telegram]

Kidus — Sun, 09 Jul 2023 09:11:08 +0000

Hi again DEV!

Welcome to part two of a nine-part series on creating a simple password generator Telegram bot! In this series, we will build a fully functional bot that generates secure passwords for Telegram users in 9 different programming languages.

For more context or a simple introduction, read the introductory post of this series. You can also find the source code here. I will also try my best to answer any questions below!

If you're a Javascript developer, Boo! Today, we'll make the bot in Golang. Go is a programming language created by Google that's fast, simple, and very cool. If you want to impress your peers with your coding skills, having a Go project or two helps.

All you will need for this one is a working Golang Runtime.

Setting Up

Once you're in your project directory, initialize a go module. You can use any name you want for the module.

go mod init go-telegram-bot

Once set up, we can install all the dependencies for our little project.

We will use godotenv to import and use .env files and this zero-dependencies telegram bot framework.

go get github.com/joho/godotenv github.com/go-telegram/bot

Set up .env

If you do not have a telegram bot token, please refer to the introductory post for instructions on acquiring a new bot token or alternatively, you can follow this official step-by-step guide.

Once we have everything installed, create a file labeled .env, and write into it the following:

BOT_TOKEN=

Make sure to append your bot token after the equals sign, we will be reading from it later. It should look something like this

BOT_TOKEN=4839574812:AAFD39kkdpWt3ywyRZergyOLMaJhac60qc

godotenv enables developers to load environment variables from a .env file into the process environment. The .env file contains key-value pairs of configuration variables, allowing developers to store sensitive information like API keys, database credentials, or other configuration values securely in a separate file. Since our bot token is of the utmost importance, this is one secure way of storing and accessing it.

Let’s start coding!

Now that everything is set up, let’s create a new file called main.go and open it in a code editor.

Let’s start by importing our dependencies.

package main

import (
    "context"
    "fmt"
    "log"
    "math/rand"
    "os"
    "os/signal"
    "strconv"
    "strings" 

    "github.com/go-telegram/bot"
    "github.com/go-telegram/bot/models"

    "github.com/joho/godotenv"
)

Now, that's a long list. Although it can seem overwhelming, I guarantee this is not as complicated as it looks. The code will be self explanatory and when in doubt, be sure to check out the Golang Documentation.

Time for our string generation function.

This function labeled generateString will receive a length parameter for the length of the generated string and return a random string containing various characters from a given character set.

// String generation function

func generateString(length int) string {

    var characters string = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*()-="

    var newString string

    for x := 0; x < length; x++ { // ++ is a statement.
        newString = newString + string(characters[rand.Intn(len(characters))])
    }
    return "||" + bot.EscapeMarkdown(newString) + "||"
}

As explained in Part #0, when a user prompts for a new password, we randomly select a character from the key string a given number of times and concatenate the characters into a new variable, which we then return.

I added one more thing to this function, right at the end. We have to escape all the symbols in the password so that we don’t accidentally apply markdown styles in our using our generated string and that’s just what the bot.EscapeMarkdown function does, this function is provided by telegram-go which we have already imported.

You might also wonder what the “||” symbols are for. As per the Telegram documentation, those are the symbols used for spoiler text.

Now for the main course. The main() function is a special type of function and it is the entry point of the executable programs. It is here where we define our initial logic.


func main() {

    err := godotenv.Load()

    if err != nil {
        log.Fatal("Error loading .env file")
    }

    fmt.Println("Running bot...")

    ctx, cancel := signal.NotifyContext(context.Background(), os.Interrupt)

    defer cancel()

    b, err := bot.New(os.Getenv("BOT_TOKEN"))

    if nil != err {
        panic(err)
    }
}

We start by loading our .env file using godotenv. After passing the error check, we create a context that will be cancelled if the program receives an interrupt signal (such as pressing Ctrl+C).

NOTE: This pattern is commonly used to gracefully shut down a server or other long-running process when an interrupt signal is received, allowing the program to clean up any resources and exit cleanly.
The defer cancel() statement ensures that the context's cancellation function is called when the function containing the ctx variable exits, regardless of how it exits.

We then get our bot instant, initialized with our bot token.

Let's be sure to add a quick println to show that our program works so far and start the bot.

fmt.Println("Running bot...")
b.Start(ctx)

The bot will now run, but... nothing will happen.

Let's give it something to do.

Starting /start

To start responding to a start command, we have to register a handler (a function) listening for it.

The following is the syntax for registering a handler.

bot.RegisterHandler(handlerType, pattern, matchType, HandlerFunc)

As you can see, we need to create a handler function to pass to the register function.

Here's our start handler.

func startHandler(ctx context.Context, b *bot.Bot, update *models.Update) {

    b.SendMessage(ctx, &bot.SendMessageParams{

        ChatID: update.Message.Chat.ID,

        Text:   "Press /generate to get a newly generated password. You can also send a number to receive a password of that length.",

    })
}

The startHandler function will be invoked every time the start command is called. The function receives the an instance of the bot and context information. Using the instance we can reply to the user with initial instructions on using our bot.

Back in the main function we register the handler like so.

b.RegisterHandler(bot.HandlerTypeMessageText, "/start", bot.MatchTypeExact, startHandler)

fmt.Println("Running bot...")

b.Start(ctx)

Since we are handling a text event and expect it to match exactly to "/start" we pass in bot.HandlerTypeMessageText and bot.MatchTypeExact for the handlerType and matchType respectively.

Time to /generate

When it comes to our password generation command, we have to prepare for two scenarios. With and without a length parameter.

If there is no parameter, we respond with a 12-character password.

If it is specified, all we do is pass that on to the generateString function. Since telegram has a character limit of 4096, we don’t have to worry about a max length.

Unlike the Typescript/Telegraf.js iteration of this bot we can split our logic at handler registration. We can assign two different functions, depending on the matchType mention earlier.

For the "/generate" implementation, we will use bot.MatchTypeExact and for the "/generate {num}" implementation, we will use bot.MatchTypePrefix.

Here is our base generateHandler.

func generateHandler(ctx context.Context, b *bot.Bot, update *models.Update) {

    b.SendMessage(ctx, &bot.SendMessageParams{

        ChatID:    update.Message.Chat.ID,

        Text:      generateString(12),

        ParseMode: models.ParseModeMarkdown,

    })
}

And here is our generateHandler with support for a number parameter.

func generateWithArgumentHandler(ctx context.Context, b *bot.Bot, update *models.Update) {

    commandArgs := strings.Split(update.Message.Text, " ")

    if len(commandArgs) != 2 {

        b.SendMessage(ctx, &bot.SendMessageParams{

            ChatID:    update.Message.Chat.ID,

            Text:      "Incorrect amount of arguments, try /help",

            ParseMode: models.ParseModeMarkdown,

        })
        return
    }

    newLength, err := strconv.Atoi(commandArgs[len(commandArgs)-1])

    if nil != err {

        b.SendMessage(ctx, &bot.SendMessageParams{

            ChatID:    update.Message.Chat.ID,

            Text:      "Be sure to use only integer parameters, try /help",

            ParseMode: models.ParseModeMarkdown,

        })

        return
    }

    b.SendMessage(ctx, &bot.SendMessageParams{

        ChatID:    update.Message.Chat.ID,

        Text:      generateString(newLength),

        ParseMode: models.ParseModeMarkdown,

    })

}

Note that we make sure to check that the command has only received one parameter and that the parameter is an integer. We also prepare messages for incorrect usage for the commands.

What is left is registering these handlers back in main.

b.RegisterHandler(bot.HandlerTypeMessageText, "/generate", bot.MatchTypeExact, generateHandler)

//Generate handler with arguments
b.RegisterHandler(bot.HandlerTypeMessageText, "/generate", bot.MatchTypePrefix, generateWithArgumentHandler)

/help me get going!

Last and kind of least, we have the /help command. Keeping it simple, here is the handler for that.

func helpHandler(ctx context.Context, b *bot.Bot, update *models.Update) {

    b.SendMessage(ctx, &bot.SendMessageParams{

        ChatID: update.Message.Chat.ID,

        Text: "Use the /generate command to create an AlphaNumeric 12 character password\\. You can provide an argument to set the length of password," +

            "\nfor example,\n `/generate 15`   to generate a string of 15 character\\.",

        ParseMode: models.ParseModeMarkdown,

    })

}

Having flavored it up a bit with Markdown, the help text is ready to go.

And as before, we register it up in main.

b.RegisterHandler(bot.HandlerTypeMessageText, "/help", bot.MatchTypeExact, helpHandler)

Well, let’s run it then.

go run main.go

Your console should display only the following

Running bot...

Try texting your bot on Telegram and everything should be working perfectly.

Debugging

If you are experiencing confusing console errors and various other issues, feel free to ask down below, I will try my best to respond to everyone.

If you see Running bot… in your console but you’re getting no responses from your bot, try adding a print in the code blocks for each command to pinpoint the problem. Again, feel free to ask for help down below.

Closing Credits

We did it!

2 done, 7 to go. Thanks for reading DEV!

If you have any questions, suggestions, or tips, please feel free to comment below. I will respond as quickly as I can.

I truly hope you enjoyed reading all of that and gained something from it. Hopefully both, but either is good.

In case you are curious about this series and whatever else I’ll be up to, drop a follow and a like, it’s much appreciated!

How to Make a Password Generator Bot - Part 1 [Typescript/Telegraf.js]

Kidus — Sun, 11 Jun 2023 08:50:52 +0000

Hi again DEV!

Welcome to part one of a nine-part series on creating a simple password generator Telegram bot! In this series, we will build a fully functional bot that generates secure passwords for Telegram users in 9 different programming languages.

If you want more context or a simple introduction, read up on the previous post of this series. You can also find the source code here. I will also try my best to answer any questions below!

I’m a full-stack web developer, which means that no matter how agnostic I am towards programming languages, I cannot escape JavaScript/TypeScript. And that is why we’ll start our first bot off in Typescript.

Let’s start by going through a checklist of what we’ll need.

Installed NodeJS Runtime
NPM or Yarn

That’s it? Yes. For now, at least. Once we have a NodeJS
runtime installed, we can instantiate our Typescript project.

Setting Up

npm init
# or
yarn init

When prompted, set your entry point to “index.ts”. You can leave everything else blank.

Once set up, we can install all the dependencies for our little project.

We will use dotenv to import and use .env files and Telegraf.js to massively simplify the development process. We will also use tsx to run our typescript files.

npm install dotenv telegraf tsx @types/node

Or if you're using yarn

yarn add dotenv telegraf tsx @types/node

Tip #1.1: In the package.json file, add the following.

"scripts": {
        "dev": "tsx watch index.ts"
    },

The scripts key lets you add custom scripts to your NodeJS project, and in this case, the dev script will run tsx with the watch argument. This will ensure that NodeJS will automatically restart every time index.ts is altered.

If you do not have a telegram bot token, please refer to the previous post for instructions on acquiring a new bot token. You can also follow this official step-by-step guide.

Once we have everything installed, create a file labeled .env, and write into it the following:

BOT_TOKEN=

Make sure to append your bot token after the equals sign, we will be reading from it later. It should look something like this

BOT_TOKEN=4839574812:AAFD39kkdpWt3ywyRZergyOLMaJhac60qc

dotenv enables developers to load environment variables from a .env file into the process environment. The .env file contains key-value pairs of configuration variables, allowing developers to store sensitive information like API keys, database credentials, or other configuration values securely in a separate file. Since our bot token is of the utmost importance, this is one secure way of storing and accessing it.

Let’s start coding!

Now that everything is set up, let’s create a new file called index.ts and open it in a code editor.

Let’s start by importing our dependencies.

import { Telegraf } from "telegraf";
import * as dotenv from "dotenv";

We will then move on to creating our string generation function.

This function, named generateString, will receive a length parameter for the length of the generated string and return a random string containing various characters from a given character set.

// String generation function
function generateString(length: number) {
    const KeyString =
        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*()-=";
    let RandString = "";
    for (let i = 0; i < length; i++) {
        /* We randomly select a character 
        from the key and add it RandString*/
        RandString += KeyString.charAt(
            Math.floor(Math.random() * KeyString.length)
        );
    }
    // Remove characters to fit the markdown rule
    return (
        "||" + RandString.replace(/[~!@#$%^&*()-_=+{}\|;:',.?]/g, "\\$&") + "||"
    );
}

You might also wonder what the “||” symbols are for. As per the Telegram documentation, those are the symbols used for spoiler text.

With our handy function implemented, it's time to initialize our telegram bot. Using the next snippet we run the default dotenv configuration and import the bot token from the process environment.

Telegram accepts a bot token to create a bot instance.

dotenv.config();
const token = process.env.BOT_TOKEN || "";
const bot = new Telegraf(token);

Let’s then launch our bot and add a simple print to show that the bot has started.

NOTE: This bot will be polling to receive information from the telegram API, if you want to look at the webhook implementation, check out the Telegraf.js documentation/repo.

bot.launch();
console.log("Running bot...");

Starting /start

Adding a start command is pretty straightforward thanks to Telegraf.js.

// Start command code
bot.start(async (ctx) =>
    ctx.reply(
        "Press /generate to get a newly generated password. You can also send a number to receive a password of that length."
    )
);

The bot.start function will be invoked every time the start command is called. The function passes the context, and using the context we can reply to the user with initial instructions on using our bot.

Time to /generate

Telegraf.js provides a handy way of describing command functions with bot.command. Similar to bot.start, the .command callback is run every time a command matching the specified string is sent.

When it comes to our password generation command, we have to prepare for two scenarios. With and without a length parameter.

If there is no parameter, we respond with a 12-character password.

If it is specified, all we do is pass that on to the generateString function. Since telegram has a character limit of 4096, we don’t have to worry about a max length.
All we have to do is check for the number of spaces and we can easily deduce the number of arguments, like so.

// Generate command code
bot.command("generate", async (ctx) => {
    const MessageArr = ctx.update.message.text.split(" ");
    if (MessageArr.length == 2) {
        return await ctx.replyWithMarkdownV2(
            generateString(Number(MessageArr[1])),
            {
                parse_mode: "MarkdownV2",
            }
        );
    } else if (MessageArr.length > 2)
        return ctx.reply("Incorrect amount of arguments, try /help");
    return await ctx.replyWithMarkdownV2(generateString(12), {
        parse_mode: "MarkdownV2",
    });
});

So maybe that got a little hairy. Let’s break it down.
We first create MessageArr to store every string that is separated by a “ “. This variable is a convenient array and we can use it to determine if there are any arguments sent with the command.

If we have only the command and one argument, we pass in that argument and return a string. If there is only the command, we generate a 12-character string and return that instead.

If we have an incorrect number of arguments, we recommend to the user the /help command.

The .replyWithMarkdownV2 function is a Telegraf.js function that lets us pass markdown text in a way that Telegram understands them.

/help! The article is ending!

Last and kind of least, we have the /help command. Keeping it simple, here is the code for that.

// Help command code
bot.command(
    "help",
    async (ctx) =>
        await ctx.replyWithMarkdownV2(
            "Use the /generate command to create an AlphaNumeric 12-character password\\. \nYou can also provide an argument to set the length of the password, " +
                "for example, `/generate 15` to generate a string of 15 character\\.",
            { parse_mode: "MarkdownV2" }
        )
);

Having flavored it up a bit with Markdown, the help text is ready to go.

Well, let’s run it then.

yarn dev

Your console should display only the following

Running bot...

Try texting your bot on Telegram and everything should be working perfectly.

Debugging

If you are experiencing confusing console errors and various other issues, feel free to ask down below, I will try my best to respond to everyone.

Closing Credits

1 done, 8 to go. Thanks for reading DEV!

If you have any questions, suggestions, or tips, please feel free to comment below. I will respond as quickly as I can.

I truly hope you enjoyed reading all of that and gained something from it. Hopefully both, but either is good.

In case you are curious about this series and whatever else I’ll be up to more stuff like this, drop a follow and a like, it’s much appreciated!

Making a Password Generator Bot in 9 Languages

Kidus — Sun, 11 Jun 2023 08:46:56 +0000

Hey there DEV!

In this 9-part series, I wanted to explore what creating a simple password generator bot would be like, in 9 different programming languages.

You might be wondering why or well, why??. The simplest answer is that I thought it would be fun. In addition to being fun, it will most definitely be interesting. As you can imagine, reimplementing the same logic across different paradigms will be simultaneously tedious and insightful, the best learning environment.

We will start with Typescript and go on to implement the same bot in Golang, Python, Rust, etc. I chose the list of languages based primarily on my personal/professional experiences and their overall popularity in the industry.

As we switch languages and progress through the list, we will learn about different libraries and tools we can use to develop each unique implementation.

As you can imagine, there will be many cases where I will choose one library or package over another.

I will try to justify my decision-making where possible, but please keep in mind that often, I AM GOING FOR WHATEVER SEEMS EASIEST. The libraries I implement happen to be whatever I find to be easiest to use and set up. By selecting them, I am by no means declaring their superiority.

Here's the github link to the finished / in progress repo in case you want to just see the source code.

Why Telegram?

It is straightforward, has good support, and I have experience with the API. I would love to do future articles for other platforms, such as Discord and Slack but probably not in 9 different languages.

Getting a bot token

To authenticate your bot with the telegram bot API, we will acquire a bot token.

Obtaining a token is as simple as opening Telegram and contacting @botfather, issuing the /newbot command, and following the steps until you receive a new token. You can find a step-by-step guide here.

Your token will look something like this:
4839574812:AAFD39kkdpWt3ywyRZergyOLMaJhac60qc

Store it somewhere safe. We will use this token for every implementation as it is necessary to communicate with your bot using the API.

So, what’s the bot?

A password generator telegram bot. What a mouthful.

Let's break it down

Okay, so, a bot with a /start (duh), /generate, and /help command. You can guess what the /start and /help commands do, actually, you can guess what all the commands do, that’s kind of the point of commands.

The /generate command will generate an AlphaNumeric + Symbol containing 12 character string. The command will also support providing a number parameter specifying the length of the generated password.

/generate 15
> AF42F$dw33EDFA3

That’s it. Simple right?

Well, one last thing, let me explain how we will actually generate the password.

Basic Password Generation

We will store a string containing all the characters we want to be in the password. This string will go something like “ABCD…-=”. Let’s call this KeyString.

When a user prompts for a new password (assuming no length parameter is specified) we will randomly select a character from the KeyString variable 12 times and concatenate the characters into a new variable, RandString. We will then message the user the newly generated RandString.

I’ve complicated this section a fair bit but it’s easy to imagine the bot gets a lot more useful and complicated. We can even add additional functionality such as password strength evaluation, memorable passwords, and so on. Again, we will go for the simplest path, which is also why mostly use built-in randomization functions.

And that’s all there is to it.

Although I will be implementing only the functionality described above, I highly encourage you to experiment and see what works and does not. That is truly the best way to learn.

Here is the list of languages as of this writing, in (hopefully) sequential order.

💙 TypeScript
🐹 Golang
🐍 Python
🦀 Rust
🔷 C#
💎 Ruby
🐪 Perl
🐘 PHP
☕ Java

Before we start, here’s a little disclaimer

What this series isn’t

This series will not attempt to be something like “The Ultimate Guide To Telegram Bot Development” for any programming language. It may serve as a quick reference on telegram bot development but only for projects with minuscule scopes.

This series will not attempt to rank and hierarchically compare various programming languages if there are comparisons at all. Implementations will be an attempt to adapt and engineer, not critique.