The current banking products in the market are complex, hard to onboard manage and expensive to operate. FIMPLE, established in January 2022 as a product-focused company addressing financial sector players' problems by creating a cloud-based system with the new generation of technology and business needs. FIMPLE is proposing a composable finance solution built based on SaaS Architecture and running on cloud. By using FIMPLE Transaction Composer banks and financial institutions can develop products and services and offer them to their customers and fintech partners.

Fimple

You can jump to any part of the United States International Cyberspace & Digital Policy Strategy here. This part is 26 of 38. Line of Effort 1: Pursue Action-Oriented Discussions Focused on Norm Implementation at the UN Sustained engagement over almost two and a half decades and across four previous administrations has yielded a framework of responsible state behavior in cyberspace repeatedly supported by all members of the UN General Assembly, which affirms the applicability of international law to states’ use of information and communication technologies, endorses adherence to voluntary norms of responsible state behavior in peacetime, and proposes practical confidence-building measures to help reduce the risk of conflict stemming from cyber incidents. The framework is the core of our vision for a cyberspace in which states behave appropriately, manage the risk of unwanted escalation, hold bad actors accountable for irresponsible activities, and work together to respond to and recover from significant cyber incidents. Implementation of these norms, however, is critical to their effectiveness. We will pursue more action-oriented discussions at the UN focused on how member states and institutions can work together to implement the framework’s essential elements and build all states’ capacity to manage cyber-related threats. To accommodate this evolving conversation, the United States and its partners have proposed a more action-oriented forum, a Program of Action (POA), as a future permanent mechanism for dialogue on cyber issues related to international security at the UN. Designed to be flexible enough to address future threats, with member states setting its direction over time, the POA will also incorporate the views of civil society, the private sector, and other non-state stakeholders. As part of advancing responsible state behavior in cyberspace, the United States and our partners will also continue to work together in regional security and other fora, such as the Organization for Security and Cooperation, Organization of American States, and the ASEAN Regional Forum, to develop and implement cyber confidence building measures. Continue Reading Here. This post was originally published on May 6, 2024, by the U.S Department of State You can jump to any part of the United States International Cyberspace & Digital Policy Strategy here. This part is 26 of 38. You can jump to any part of the United States International Cyberspace & Digital Policy Strategy here . This part is 26 of 38. here Line of Effort 1: Pursue Action-Oriented Discussions Focused on Norm Implementation at the UN Sustained engagement over almost two and a half decades and across four previous administrations has yielded a framework of responsible state behavior in cyberspace repeatedly supported by all members of the UN General Assembly, which affirms the applicability of international law to states’ use of information and communication technologies, endorses adherence to voluntary norms of responsible state behavior in peacetime, and proposes practical confidence-building measures to help reduce the risk of conflict stemming from cyber incidents. The framework is the core of our vision for a cyberspace in which states behave appropriately, manage the risk of unwanted escalation, hold bad actors accountable for irresponsible activities, and work together to respond to and recover from significant cyber incidents. Implementation of these norms, however, is critical to their effectiveness. We will pursue more action-oriented discussions at the UN focused on how member states and institutions can work together to implement the framework’s essential elements and build all states’ capacity to manage cyber-related threats. To accommodate this evolving conversation, the United States and its partners have proposed a more action-oriented forum, a Program of Action (POA), as a future permanent mechanism for dialogue on cyber issues related to international security at the UN. Designed to be flexible enough to address future threats, with member states setting its direction over time, the POA will also incorporate the views of civil society, the private sector, and other non-state stakeholders. As part of advancing responsible state behavior in cyberspace, the United States and our partners will also continue to work together in regional security and other fora, such as the Organization for Security and Cooperation, Organization of American States, and the ASEAN Regional Forum, to develop and implement cyber confidence building measures. Continue Reading Here. Continue Reading Here . Here This post was originally published on May 6, 2024, by the U.S Department of State This post was originally published on May 6, 2024, by the U.S Department of State by the U.S Department of State

U.S. Champions Action-Oriented Cyber Norms Implementation at the UN

জাতিসংঘে ইউএস চ্যাম্পিয়নস অ্যাকশন-ওরিয়েন্টেড সাইবার নিয়ম বাস্তবায়ন

USA setzen sich bei den Vereinten Nationen für die Umsetzung handlungsorientierter Cybernormen ein

Estados Unidos promueve la implementación de normas cibernéticas orientadas a la acción en la ONU

Les États-Unis défendent la mise en œuvre de normes cybernétiques orientées vers l’action à l’ONU

संयुक्त राष्ट्र में कार्रवाई-उन्मुख साइबर मानदंडों के कार्यान्वयन में अमेरिका अग्रणी

米国は国連で行動指向型サイバー規範の実施を推進

UN에서 미국 챔피언의 행동 중심 사이버 규범 구현

Os EUA defendem a implementação de normas cibernéticas orientadas para a ação na ONU

Американские чемпионы по внедрению кибернорм, ориентированных на действия, в ООН

ABD Şampiyonları BM'de Eylem Odaklı Siber Normlar Uygulaması

Những nhà tiên phong của Hoa Kỳ thực hiện các quy tắc mạng theo định hướng hành động tại Liên hợp quốc

美国倡导在联合国实施以行动为导向的网络规范

Six Simple Words for A Software Developer to Survive the Gen AI Revolution

This paper is available on arxiv under CC BY-NC-ND 4.0 DEED license.
Authors:
(1) Ehud Shapiro,  Department of Computer Science and Applied Math, Weizmann Institute of Science, Israel and ehud.shapiro@weizmann.ac.il. Table of Links Abstract and Introduction
Grassroots Protocols
Grassroots Implementation of Grassroots Dissemination
Applications of Grassroots Dissemination Supporting Digital Sovereignty
Future Work & Discussion
References
A. Preliminaries: Asynchronous Distributed Multiagent Transition Systems
B. All-to-All Dissemination is not Grassroots
C. Proofs Grassroots Implementation of Grassroots Dissemination Here we present an implementation of the Grassroots Dissemination protocol GD, as depicted in Figure 1: The blocklace-based Cordial Grassroots Dissemination Protocol CGD (Def. 26), and its proof of being grassroots (Prop.28). The implementation σ (Def.33) of GD by CGD, and its proof of being grassroots (Thm. 29). Algorithm 1 with pseudocode for blocklace utilities and Algorithm 2 with pseudocode realizing CGD for the model of Asynchrony. The Cordial Grassroots Dissemination protocol employs the notions of follows, needs, friend, and friendship graph similarly to GD (Def. 14). A key difference is that in Grassroots Dissemination an agent that needs a block b may receive it from a friend that has b ‘by magic’, whereas in Cordial Grassroots Dissemination such an agent p must first disclose to a friend q the blocks it knows and the agents it follows, implying that it needs b, and based on such disclosure q may cordially send b to p. We employ the blocklace [15] to realize these principles. The blocklace is a DAGlike partially ordered generalization of the totally-ordered blockchain data structure that functions as a fault resilient, conflict-free replicated data type [26]. While the mathematical construction and proofs of the blocklace realization presented next are quite involved, the final result, presented as 30 lines of pseudocode in Algs. 1, 2, is quite simple. 3.1 Blocklace Preliminaries Each block in a blocklace may contain a finite set of cryptographic hash pointers to previous blocks, in contrast to one pointer (or zero for the initial block) in a blockchain. We assume a payload function X as above, and a collision-free cryptographic hash function hash. 3.2 The Cordial Grassroots Dissemination Protocol The Cordial Grassroots Dissemination protocol CGD realizes the two principles as follows. Disclosure is realized by a new p-block serving as a multichannel ack/nack message, informing its recipient whether it follows another agent q, and if so also of the latest q-block known to p, for every q ∈ P. This is realized by the notions defined next and illustrated in Figure 3. As we shall see, a correct agent p always maintains a p-closed blocklace and produces only maximally-closed p-blocks, thus abiding by the principle of disclosure. The local state in the protocol presented includes a blocklace and block messages. Notes. Disclosure is realized by the Create&Disclose transition choosing a maximally-closed p-block, and cordiality is realized by the Cordially-Send-b-to-q, with which p sends any p’-block b it knows to any friend q that p believes needs it. Namely, for which p knows that q follows p’ and p doesn’t know that q knows b. If q knows b then p would eventually know that, when it receives the next q-block that discloses knowledge of b. The special case of Cordially-Send, where p = p’ and b is a p-block, is simply dissemination among friends. Simple (volitional) Send can be used by an agent to send any block it has to any other agent. The recipient of a volitionally sent q-block can then follow q starting from that block. Similarly, two agents can send each other blocks to become friends. The liveness condition requires an agent to disclose every so often the blocks they know, to eventually send any block that satisfies the specified conditions, and receive any block sent to it that it does not know already, but it does not require an agent to follow other agents or to voluntarily send any block. Unlike in GD, where p can construct a simple initial q-block, here the initial q-block includes a hash pointer signed by q, which cannot be created/forged by p. Asynchrony. The model of asynchrony assumes that each message sent among correct agents is eventually received and an that an adversary may control, in addition to the faulty agents, also the order of message arrival among all agents. These assumptions are satisfied by the liveness requirement of CGD. Liveness ensures that communication is reliable, as any message sent among correct miners is eventually received, yet there is no bound on the finite delay of message arrival, as postulated by the model. Correctness of an agent requires it to be correct in all computations, hence the system has to be resilient to an adversary that controls not only faulty agents but also the order of transitions by correct agents. Controlling the order of Receive transitions amounts to control of the order of message arrival, as postulated by the model. The following proposition is the analogue of Proposition 16 for GD, with an analogue proof. 3.3 A Grassroots Implementation of CGD by GD We use the theorem above to show that: Theorem 29. CGD can provide a grassroots implementation of GD. We employ the notion of monotonic-completeness wrt to a partial order to prove the correctness of the implementation: 3.4 Pseudocode Implementation of Grassroots Cordial Dissemination The Cordial Grassroots Dissemination protocol was specified as a family of asynchronous distributed multiagent transition systems CGD (Def. 26). Asynchrony. Algorithm 2 presents pseudocode implementation of the protocol for a single agent p for the model of Asynchrony. The comments indicate which transition rule is realized by what code. We assume that the agent p can interact with the protocol application that runs on their personal device. In particular, p can specify the payload for a new block or decide to send any block it knows to any other agent. As according to the model of asynchrony each message sent is eventually received, we assume the reliably_send construct to keep a record of sent messages so as not to send the same message to the same agent twice, implementing the requirement (q, b) ∈/ Out of the Cordially-Send-b-to-q transition. The construct upon eventually is also geared for the model of asynchrony: It is a ‘timeless timeout’ with no notion of time, only with a guarantee of eventuality. The implementation of grassroots dissemination for asynchrony assumes reliable communication, readily implemented by TCP. However, for grassroots dissemination to reach its full potential it must be designed for mobile agents using unreliable communication, namely UDP. With TCP, smartphones can establish a connection only with the help of an agreed-upon third party, which undermines grassroots and digital sovereignty, and the connection needs reestablishing upon roaming to a new IP address. With UDP, a connection is not needed and incorporating the sender’s current IP address in a block lets recipients (re)transmit blocks to the sender’s updated IP address, allowing roaming agents to remain connected to their friends. Furthermore, the ability of a block in a blocklace to function as a multichannel ack/nack message shines in a UDP implementation, as a received p-block b (even if received indirectly, not from p) makes redundant the (re)transmission to p of any block observed by b. A refinement of the Cordial Grassroots Dissemination protocol for mobile (address-hopping) agents communicating over an unreliable network, namely smartphones communicating via UDP, is presented as Alg. 3. Mobile Agents Communicating via UDP. Cordial dissemination over UDP exploits the ack/nak information of blocklace blocks to its fullest, by p retransmitting to every friend q every block b that p knows (not only p-blocks) and believes that q needs, until q acknowledges knowing b. The sending of unsolicited blocks (Send-b-to-q) does not guaranteed delivery, and if delivered does not guarantee acknowledgement, unless the the block is a friendship offer (with a (‘follow’, q) payload), and the recipient q accept the offer (creating a block with a (‘follow’, p) payload). Assuming that timeouts are separated by seconds and mobile address hopping is separated by hours, then the probability of two friends hopping together without one successfully informing the other of its new IP address is around 10−7 . If the two hopping friends have a stationary joint friend, then it is enough that one of the hoppers successfully informs the stationary friend of the address change, for the other hopper to soon know this new address from the stationary friend. Under the same assumptions, the probability of a clique of n friends loosing a member due to all hopping simultaneously is around 10−3.6∗n. Note that such a loss is not terminal – assuming that friends have redundant ways to communicate (physical meetings, email, SMS, global social media), new addresses can be communicated and the digital friendship restored. We note that the timer need not be of fixed duration and global – an adaptive timer for each friend might prove more efficient. This paper is available on arxiv under CC BY-NC-ND 4.0 DEED license. Authors: (1) Ehud Shapiro,  Department of Computer Science and Applied Math, Weizmann Institute of Science, Israel and ehud.shapiro@weizmann.ac.il. This paper is available on arxiv under CC BY-NC-ND 4.0 DEED license. Authors: Authors: (1) Ehud Shapiro,  Department of Computer Science and Applied Math, Weizmann Institute of Science, Israel and ehud.shapiro@weizmann.ac.il. Table of Links Abstract and Introduction Grassroots Protocols Grassroots Implementation of Grassroots Dissemination Applications of Grassroots Dissemination Supporting Digital Sovereignty Future Work & Discussion References A. Preliminaries: Asynchronous Distributed Multiagent Transition Systems B. All-to-All Dissemination is not Grassroots C. Proofs Abstract and Introduction Abstract and Introduction Grassroots Protocols Grassroots Protocols Grassroots Implementation of Grassroots Dissemination Grassroots Implementation of Grassroots Dissemination Applications of Grassroots Dissemination Supporting Digital Sovereignty Applications of Grassroots Dissemination Supporting Digital Sovereignty Future Work & Discussion Future Work & Discussion References References A. Preliminaries: Asynchronous Distributed Multiagent Transition Systems A. Preliminaries: Asynchronous Distributed Multiagent Transition Systems B. All-to-All Dissemination is not Grassroots B. All-to-All Dissemination is not Grassroots C. Proofs C. Proofs Grassroots Implementation of Grassroots Dissemination Here we present an implementation of the Grassroots Dissemination protocol GD, as depicted in Figure 1: The blocklace-based Cordial Grassroots Dissemination Protocol CGD (Def. 26), and its proof of being grassroots (Prop.28). The implementation σ (Def.33) of GD by CGD, and its proof of being grassroots (Thm. 29). Algorithm 1 with pseudocode for blocklace utilities and Algorithm 2 with pseudocode realizing CGD for the model of Asynchrony. The Cordial Grassroots Dissemination protocol employs the notions of follows, needs, friend, and friendship graph similarly to GD (Def. 14). A key difference is that in Grassroots Dissemination an agent that needs a block b may receive it from a friend that has b ‘by magic’, whereas in Cordial Grassroots Dissemination such an agent p must first disclose to a friend q the blocks it knows and the agents it follows, implying that it needs b, and based on such disclosure q may cordially send b to p. We employ the blocklace [15] to realize these principles. The blocklace is a DAGlike partially ordered generalization of the totally-ordered blockchain data structure that functions as a fault resilient, conflict-free replicated data type [26]. While the mathematical construction and proofs of the blocklace realization presented next are quite involved, the final result, presented as 30 lines of pseudocode in Algs. 1, 2, is quite simple. 3.1 Blocklace Preliminaries 3.1 Blocklace Preliminaries Each block in a blocklace may contain a finite set of cryptographic hash pointers to previous blocks, in contrast to one pointer (or zero for the initial block) in a blockchain. We assume a payload function X as above, and a collision-free cryptographic hash function hash. 3.2 The Cordial Grassroots Dissemination Protocol 3.2 The Cordial Grassroots Dissemination Protocol The Cordial Grassroots Dissemination protocol CGD realizes the two principles as follows. Disclosure is realized by a new p-block serving as a multichannel ack/nack message, informing its recipient whether it follows another agent q, and if so also of the latest q-block known to p, for every q ∈ P. This is realized by the notions defined next and illustrated in Figure 3. As we shall see, a correct agent p always maintains a p-closed blocklace and produces only maximally-closed p-blocks, thus abiding by the principle of disclosure. The local state in the protocol presented includes a blocklace and block messages. Notes. Disclosure is realized by the Create&Disclose transition choosing a maximally-closed p-block, and cordiality is realized by the Cordially-Send-b-to-q, with which p sends any p’-block b it knows to any friend q that p believes needs it. Namely, for which p knows that q follows p’ and p doesn’t know that q knows b. If q knows b then p would eventually know that, when it receives the next q-block that discloses knowledge of b. The special case of Cordially-Send, where p = p’ and b is a p-block, is simply dissemination among friends. Simple (volitional) Send can be used by an agent to send any block it has to any other agent. The recipient of a volitionally sent q-block can then follow q starting from that block. Similarly, two agents can send each other blocks to become friends. The liveness condition requires an agent to disclose every so often the blocks they know, to eventually send any block that satisfies the specified conditions, and receive any block sent to it that it does not know already, but it does not require an agent to follow other agents or to voluntarily send any block. Notes. Unlike in GD, where p can construct a simple initial q-block, here the initial q-block includes a hash pointer signed by q, which cannot be created/forged by p. Asynchrony. The model of asynchrony assumes that each message sent among correct agents is eventually received and an that an adversary may control, in addition to the faulty agents, also the order of message arrival among all agents. These assumptions are satisfied by the liveness requirement of CGD. Liveness ensures that communication is reliable, as any message sent among correct miners is eventually received, yet there is no bound on the finite delay of message arrival, as postulated by the model. Correctness of an agent requires it to be correct in all computations, hence the system has to be resilient to an adversary that controls not only faulty agents but also the order of transitions by correct agents. Controlling the order of Receive transitions amounts to control of the order of message arrival, as postulated by the model. The following proposition is the analogue of Proposition 16 for GD, with an analogue proof. 3.3 A Grassroots Implementation of CGD by GD 3.3 A Grassroots Implementation of CGD by GD We use the theorem above to show that: Theorem 29. CGD can provide a grassroots implementation of GD. Theorem 29. We employ the notion of monotonic-completeness wrt to a partial order to prove the correctness of the implementation: 3.4 Pseudocode Implementation of Grassroots Cordial Dissemination 3.4 Pseudocode Implementation of Grassroots Cordial Dissemination The Cordial Grassroots Dissemination protocol was specified as a family of asynchronous distributed multiagent transition systems CGD (Def. 26). Asynchrony. Algorithm 2 presents pseudocode implementation of the protocol for a single agent p for the model of Asynchrony. The comments indicate which transition rule is realized by what code. We assume that the agent p can interact with the protocol application that runs on their personal device. In particular, p can specify the payload for a new block or decide to send any block it knows to any other agent. As according to the model of asynchrony each message sent is eventually received, we assume the reliably_send construct to keep a record of sent messages so as not to send the same message to the same agent twice, implementing the requirement (q, b) ∈/ Out of the Cordially-Send-b-to-q transition. The construct upon eventually is also geared for the model of asynchrony: It is a ‘timeless timeout’ with no notion of time, only with a guarantee of eventuality. Asynchrony. The implementation of grassroots dissemination for asynchrony assumes reliable communication, readily implemented by TCP. However, for grassroots dissemination to reach its full potential it must be designed for mobile agents using unreliable communication, namely UDP. With TCP, smartphones can establish a connection only with the help of an agreed-upon third party, which undermines grassroots and digital sovereignty, and the connection needs reestablishing upon roaming to a new IP address. With UDP, a connection is not needed and incorporating the sender’s current IP address in a block lets recipients (re)transmit blocks to the sender’s updated IP address, allowing roaming agents to remain connected to their friends. Furthermore, the ability of a block in a blocklace to function as a multichannel ack/nack message shines in a UDP implementation, as a received p-block b (even if received indirectly, not from p) makes redundant the (re)transmission to p of any block observed by b. A refinement of the Cordial Grassroots Dissemination protocol for mobile (address-hopping) agents communicating over an unreliable network, namely smartphones communicating via UDP, is presented as Alg. 3. Mobile Agents Communicating via UDP. Cordial dissemination over UDP exploits the ack/nak information of blocklace blocks to its fullest, by p retransmitting to every friend q every block b that p knows (not only p-blocks) and believes that q needs, until q acknowledges knowing b. The sending of unsolicited blocks (Send-b-to-q) does not guaranteed delivery, and if delivered does not guarantee acknowledgement, unless the the block is a friendship offer (with a (‘follow’, q) payload), and the recipient q accept the offer (creating a block with a (‘follow’, p) payload). Assuming that timeouts are separated by seconds and mobile address hopping is separated by hours, then the probability of two friends hopping together without one successfully informing the other of its new IP address is around 10−7 . If the two hopping friends have a stationary joint friend, then it is enough that one of the hoppers successfully informs the stationary friend of the address change, for the other hopper to soon know this new address from the stationary friend. Under the same assumptions, the probability of a clique of n friends loosing a member due to all hopping simultaneously is around 10−3.6∗n. Note that such a loss is not terminal – assuming that friends have redundant ways to communicate (physical meetings, email, SMS, global social media), new addresses can be communicated and the digital friendship restored. We note that the timer need not be of fixed duration and global – an adaptive timer for each friend might prove more efficient. Mobile Agents Communicating via UDP.

Grassroots Implementation of Grassroots Dissemination

Neural Network for Valuing Bitcoin: Numerical Results, Implementation and Discussion

Authors:
(1) Anna-Katharina Wickert, Technische Universität Darmstadt, Darmstadt, Germany (wickert@cs.tu-darmstadt.de);
(2) Lars Baumgärtner, Technische Universität Darmstadt, Darmstadt, Germany (baumgaertner@cs.tu-darmstadt.de);
(3) Florian Breitfelder, Technische Universität Darmstadt, Darmstadt, Germany (florian.breitfelder@tu-darmstadt.de);
(4) Mira Mezini, Technische Universität Darmstadt, Darmstadt, Germany (mezini@cs.tu-darmstadt.de). Table of Links Abstract and 1 Introduction 2 Background 3 Design and Implementation of Licma and 3.1 Design 3.2 Implementation 4 Methodology and 4.1 Searching and Downloading Python Apps 4.2 Comparison with Previous Studies 5 Evaluation and 5.1 GitHub Python Projects 5.2 MicroPython 6 Comparison with previous studies 7 Threats to Validity 8 Related Work 9 Conclusion, Acknowledgments, and References 5.2 MicroPython When we applied LICMA upon the 5 source files containing crypto API usages of the MicroPython data set, we identified no misuse. For this reason, we inspected the MicroPython repositories for usages of other crypto functions not covered by LICMA and identified 5 additional files. We notice that the crypto module ucryptolib which is provided by MicroPython, is only used by tests in 2 projects. For the remaining 3 findings, the crypto functions are written in C rather than Python. Thus, these files were removed due to our filter steps described in Section 4.1.2. Our small analysis of MicroPython projects shows that for further exploration of MicroPython applications, we need to consider custom implementations of AES in Python and C. This seems to be a common pattern for embedded code where performance is important and low-level code is often shipped as custom C blobs. Thus, we can observe the importance of hybrid analysis approaches [5, 10]. This paper is available on arxiv under CC BY 4.0 DEED license. Authors: (1) Anna-Katharina Wickert, Technische Universität Darmstadt, Darmstadt, Germany (wickert@cs.tu-darmstadt.de); (2) Lars Baumgärtner, Technische Universität Darmstadt, Darmstadt, Germany (baumgaertner@cs.tu-darmstadt.de); (3) Florian Breitfelder, Technische Universität Darmstadt, Darmstadt, Germany (florian.breitfelder@tu-darmstadt.de); (4) Mira Mezini, Technische Universität Darmstadt, Darmstadt, Germany (mezini@cs.tu-darmstadt.de). Authors: Authors: (1) Anna-Katharina Wickert, Technische Universität Darmstadt, Darmstadt, Germany (wickert@cs.tu-darmstadt.de); (2) Lars Baumgärtner, Technische Universität Darmstadt, Darmstadt, Germany (baumgaertner@cs.tu-darmstadt.de); (3) Florian Breitfelder, Technische Universität Darmstadt, Darmstadt, Germany (florian.breitfelder@tu-darmstadt.de); (4) Mira Mezini, Technische Universität Darmstadt, Darmstadt, Germany (mezini@cs.tu-darmstadt.de). Table of Links Abstract and 1 Introduction Abstract and 1 Introduction 2 Background 2 Background 3 Design and Implementation of Licma and 3.1 Design 3 Design and Implementation of Licma and 3.1 Design 3.2 Implementation 3.2 Implementation 4 Methodology and 4.1 Searching and Downloading Python Apps 4 Methodology and 4.1 Searching and Downloading Python Apps 4.2 Comparison with Previous Studies 4.2 Comparison with Previous Studies 5 Evaluation and 5.1 GitHub Python Projects 5 Evaluation and 5.1 GitHub Python Projects 5.2 MicroPython 5.2 MicroPython 6 Comparison with previous studies 6 Comparison with previous studies 7 Threats to Validity 7 Threats to Validity 8 Related Work 8 Related Work 9 Conclusion, Acknowledgments, and References 9 Conclusion, Acknowledgments, and References 5.2 MicroPython When we applied LICMA upon the 5 source files containing crypto API usages of the MicroPython data set, we identified no misuse. For this reason, we inspected the MicroPython repositories for usages of other crypto functions not covered by LICMA and identified 5 additional files. We notice that the crypto module ucryptolib which is provided by MicroPython, is only used by tests in 2 projects. For the remaining 3 findings, the crypto functions are written in C rather than Python. Thus, these files were removed due to our filter steps described in Section 4.1.2. LICMA LICMA Our small analysis of MicroPython projects shows that for further exploration of MicroPython applications, we need to consider custom implementations of AES in Python and C. This seems to be a common pattern for embedded code where performance is important and low-level code is often shipped as custom C blobs. Thus, we can observe the importance of hybrid analysis approaches [5, 10]. This paper is available on arxiv under CC BY 4.0 DEED license. This paper is available on arxiv under CC BY 4.0 DEED license. available on arxiv

MicroPython Analysis: Exploring Crypto API Usage and Custom Implementations

Authors:
(1) Anna-Katharina Wickert, Technische Universität Darmstadt, Darmstadt, Germany (wickert@cs.tu-darmstadt.de);
(2) Lars Baumgärtner, Technische Universität Darmstadt, Darmstadt, Germany (baumgaertner@cs.tu-darmstadt.de);
(3) Florian Breitfelder, Technische Universität Darmstadt, Darmstadt, Germany (florian.breitfelder@tu-darmstadt.de);
(4) Mira Mezini, Technische Universität Darmstadt, Darmstadt, Germany (mezini@cs.tu-darmstadt.de). Table of Links Abstract and 1 Introduction 2 Background 3 Design and Implementation of Licma and 3.1 Design 3.2 Implementation 4 Methodology and 4.1 Searching and Downloading Python Apps 4.2 Comparison with Previous Studies 5 Evaluation and 5.1 GitHub Python Projects 5.2 MicroPython 6 Comparison with previous studies 7 Threats to Validity 8 Related Work 9 Conclusion, Acknowledgments, and References 3.2 Implementation For our study, we implemented Python and Java analysis components. For Python, we cover 5 different crypto modules: cryptography, M2Crypto, PyCrypto, PyNaCl, ucryptolib. This selection is based upon the inspected Python modules by Acar et al. [1] which is based on the libraries’ popularity, their possibility to solve common crypto tasks, and a mix of usability focus, e.g., API-design with ignoring usability up to usability as a main focus. However, we dropped the deprecated module Keyczar, and added the MicroPython library ucryptolib. As the six rules are defined with the JCA in mind [4], we could not implement all of these rules for Python. For none of the Python modules, a misuse of §6 is possible due to the design of the APIs as there are no secure random number generators present that can be initialized with a static seed. Further, LICMA supports only §3 and §4 for PyNaCl and only §1, §2 and §3 for ucryptolib. The derivation is due to a different API design which avoids the respective misuses. We present an overview of the implemented APIs and the covered rules in Table 2. Our implementation of LICMA is available on GitHub[4]. This paper is available on arxiv under CC BY 4.0 DEED license. [4] https://github.com/stg-tud/licma Authors: (1) Anna-Katharina Wickert, Technische Universität Darmstadt, Darmstadt, Germany (wickert@cs.tu-darmstadt.de); (2) Lars Baumgärtner, Technische Universität Darmstadt, Darmstadt, Germany (baumgaertner@cs.tu-darmstadt.de); (3) Florian Breitfelder, Technische Universität Darmstadt, Darmstadt, Germany (florian.breitfelder@tu-darmstadt.de); (4) Mira Mezini, Technische Universität Darmstadt, Darmstadt, Germany (mezini@cs.tu-darmstadt.de). Authors: Authors: (1) Anna-Katharina Wickert, Technische Universität Darmstadt, Darmstadt, Germany (wickert@cs.tu-darmstadt.de); (2) Lars Baumgärtner, Technische Universität Darmstadt, Darmstadt, Germany (baumgaertner@cs.tu-darmstadt.de); (3) Florian Breitfelder, Technische Universität Darmstadt, Darmstadt, Germany (florian.breitfelder@tu-darmstadt.de); (4) Mira Mezini, Technische Universität Darmstadt, Darmstadt, Germany (mezini@cs.tu-darmstadt.de). Table of Links Abstract and 1 Introduction Abstract and 1 Introduction 2 Background 2 Background 3 Design and Implementation of Licma and 3.1 Design 3 Design and Implementation of Licma and 3.1 Design 3.2 Implementation 3.2 Implementation 4 Methodology and 4.1 Searching and Downloading Python Apps 4 Methodology and 4.1 Searching and Downloading Python Apps 4.2 Comparison with Previous Studies 4.2 Comparison with Previous Studies 5 Evaluation and 5.1 GitHub Python Projects 5 Evaluation and 5.1 GitHub Python Projects 5.2 MicroPython 5.2 MicroPython 6 Comparison with previous studies 6 Comparison with previous studies 7 Threats to Validity 7 Threats to Validity 8 Related Work 8 Related Work 9 Conclusion, Acknowledgments, and References 9 Conclusion, Acknowledgments, and References 3.2 Implementation For our study, we implemented Python and Java analysis components. For Python, we cover 5 different crypto modules: cryptography , M2Crypto, PyCrypto, PyNaCl, ucryptolib . This selection is based cryptography M2Crypto, PyCrypto, PyNaCl, ucryptolib upon the inspected Python modules by Acar et al. [1] which is based on the libraries’ popularity, their possibility to solve common crypto tasks, and a mix of usability focus, e.g., API-design with ignoring usability up to usability as a main focus. However, we dropped the deprecated module Keyczar , and added the MicroPython library ucryptolib . Keyczar ucryptolib As the six rules are defined with the JCA in mind [4], we could not implement all of these rules for Python. For none of the Python modules, a misuse of §6 is possible due to the design of the APIs as there are no secure random number generators present that can be initialized with a static seed. Further, LICMA supports only §3 and §4 for PyNaCl and only §1, §2 and §3 for ucryptolib . The derivation is due to a different API design which avoids the respective misuses. We present an overview of the implemented APIs and the covered rules in Table 2. LICMA PyNaCl ucryptolib Our implementation of LICMA is available on GitHub[4]. LICMA This paper is available on arxiv under CC BY 4.0 DEED license. This paper is available on arxiv under CC BY 4.0 DEED license. available on arxiv [4] https://github.com/stg-tud/licma https://github.com/stg-tud/licma

Implementing LICMA: Python and Java Analysis Components for Crypto Misuse Detection

Authors:
(1) Anna-Katharina Wickert, Technische Universität Darmstadt, Darmstadt, Germany (wickert@cs.tu-darmstadt.de);
(2) Lars Baumgärtner, Technische Universität Darmstadt, Darmstadt, Germany (baumgaertner@cs.tu-darmstadt.de);
(3) Florian Breitfelder, Technische Universität Darmstadt, Darmstadt, Germany (florian.breitfelder@tu-darmstadt.de);
(4) Mira Mezini, Technische Universität Darmstadt, Darmstadt, Germany (mezini@cs.tu-darmstadt.de). Table of Links Abstract and 1 Introduction 2 Background 3 Design and Implementation of Licma and 3.1 Design 3.2 Implementation 4 Methodology and 4.1 Searching and Downloading Python Apps 4.2 Comparison with Previous Studies 5 Evaluation and 5.1 GitHub Python Projects 5.2 MicroPython 6 Comparison with previous studies 7 Threats to Validity 8 Related Work 9 Conclusion, Acknowledgments, and References 3 DESIGN AND IMPLEMENTATION OF LICMA In this section, we describe the design of our static analysis tool LICMA, and discuss the implementation in more detail. 3.1 Design A general overview of LICMA is given in Figure 1. First, we parse a source code file into the respective Abstract Syntax Tree (AST). More specifically, we use Babelfish [2] to create a Universal Abstract Syntax Tree (UAST) which combines language-independent AST elements with language-specific elements. For simplicity, we use the term AST in the remainder of the paper. Second, we apply the LICMA analysis upon the AST to identify potential misuses of our crypto rules. Based upon the rule defining a misuse, the analysis checks for a violation of the rule within the source code and triggers a backward analysis for this task. The backward slice is created by filtering the AST with the help of XPath[3] queries, and works as follows: First, the backward slicing algorithm (BSA) identifies all source code lines that are referred within the respective rule. An example of the slicing criterion is a function call parameter like the key for a crypto function. Second, the BSA determines for all function calls if the parameter is either hard-coded, a local assignment, or a global assignment. If one of the three cases is fulfilled, the corresponding value is returned. This value is checked against a function defined in the rule, e.g., if the value is smaller than 1,000 for §5. In the negative case, the BSA looks for the caller of the function, and checks the caller’s parameters as described above. The algorithm stops if a value is returned or no further callers to analyse are available, and returns the result of the analysis. For its reports, LICMA distinguishes between a potential misuse if it can not resolve the value of interest due to missing callers, and a definite misuse if it is resolved to an insecure option. This paper is available on arxiv under CC BY 4.0 DEED license. [2] https://github.com/bblfsh/bblfshd [3] https://www.w3.org/TR/xpath/ Authors: (1) Anna-Katharina Wickert, Technische Universität Darmstadt, Darmstadt, Germany (wickert@cs.tu-darmstadt.de); (2) Lars Baumgärtner, Technische Universität Darmstadt, Darmstadt, Germany (baumgaertner@cs.tu-darmstadt.de); (3) Florian Breitfelder, Technische Universität Darmstadt, Darmstadt, Germany (florian.breitfelder@tu-darmstadt.de); (4) Mira Mezini, Technische Universität Darmstadt, Darmstadt, Germany (mezini@cs.tu-darmstadt.de). Authors: Authors: (1) Anna-Katharina Wickert, Technische Universität Darmstadt, Darmstadt, Germany (wickert@cs.tu-darmstadt.de); (2) Lars Baumgärtner, Technische Universität Darmstadt, Darmstadt, Germany (baumgaertner@cs.tu-darmstadt.de); (3) Florian Breitfelder, Technische Universität Darmstadt, Darmstadt, Germany (florian.breitfelder@tu-darmstadt.de); (4) Mira Mezini, Technische Universität Darmstadt, Darmstadt, Germany (mezini@cs.tu-darmstadt.de). Table of Links Abstract and 1 Introduction Abstract and 1 Introduction 2 Background 2 Background 3 Design and Implementation of Licma and 3.1 Design 3 Design and Implementation of Licma and 3.1 Design 3.2 Implementation 3.2 Implementation 4 Methodology and 4.1 Searching and Downloading Python Apps 4 Methodology and 4.1 Searching and Downloading Python Apps 4.2 Comparison with Previous Studies 4.2 Comparison with Previous Studies 5 Evaluation and 5.1 GitHub Python Projects 5 Evaluation and 5.1 GitHub Python Projects 5.2 MicroPython 5.2 MicroPython 6 Comparison with previous studies 6 Comparison with previous studies 7 Threats to Validity 7 Threats to Validity 8 Related Work 8 Related Work 9 Conclusion, Acknowledgments, and References 9 Conclusion, Acknowledgments, and References 3 DESIGN AND IMPLEMENTATION OF LICMA In this section, we describe the design of our static analysis tool LICMA , and discuss the implementation in more detail. LICMA 3.1 Design A general overview of LICMA is given in Figure 1. First, we parse a source code file into the respective Abstract Syntax Tree (AST). More specifically, we use Babelfish [2] to create a Universal Abstract Syntax Tree (UAST) which combines language-independent AST elements with language-specific elements. For simplicity, we use the term AST in the remainder of the paper. Second, we apply the LICMA analysis upon the AST to identify potential misuses of our crypto rules. LICMA Babelfish LICMA Based upon the rule defining a misuse, the analysis checks for a violation of the rule within the source code and triggers a backward analysis for this task. The backward slice is created by filtering the AST with the help of XPath[3] queries, and works as follows: First, the backward slicing algorithm (BSA) identifies all source code lines that are referred within the respective rule. An example of the slicing criterion is a function call parameter like the key for a crypto function. Second, the BSA determines for all function calls if the parameter is either hard-coded, a local assignment, or a global assignment. If one of the three cases is fulfilled, the corresponding value is returned. This value is checked against a function defined in the rule, e.g., if the value is smaller than 1,000 for §5. In the negative case, the BSA looks for the caller of the function, and checks the caller’s parameters as described above. The algorithm stops if a value is returned or no further callers to analyse are available, and returns the result of the analysis. For its reports, LICMA distinguishes between a potential misuse if it can not resolve the value of interest due to missing callers, and a definite misuse if it is resolved to an insecure option. This paper is available on arxiv under CC BY 4.0 DEED license. This paper is available on arxiv under CC BY 4.0 DEED license. available on arxiv [2] https://github.com/bblfsh/bblfshd https://github.com/bblfsh/bblfshd [3] https://www.w3.org/TR/xpath/ https://www.w3.org/TR/xpath/

Python Crypto API Misuses in the Wild: Design and Implementation of LICMA

Get Ready, Future Web Developers! Let's create a simple HTML website that connects to a Postgres Database. For this example, we will be using JavaScript (Node JS, and Express JS) for its middleware functionalities. Whether you want to showcase your portfolio, run a blog, or complete a due mini project on web development, web development is a skill that's still in demand. The Learning Path Ahead We'll dive into the process of building a simple HTML website from scratch. We'll explore how to integrate a Postgres database, using JavaScript as middleware to handle API requests. To spice things up, we can also use Bootstrap5 to design the webpage! But that will be covered in a different blog. Technologies Used: HTML5
Postgres (Database)
Express JS (Backend) Prerequisites Make sure Postgres is downloaded and ready to use. Also, download Node JS for installing npm packages like Express JS, Body Parser and Postgres APIs.
Download Postgres here
Download NodeJS here Step 1: Setup Postgres Database Create a new Postgres Database either using psql, which is the CLI for running SQL commands or a graphical user interface like pgAdmin (which comes pre-installed). For this demonstration, we will be using psql for creating the database. Open psql and enter the credentials to get started. Create a database called webapp and connect to it!
(You can use any name you want for your project!) CREATE database webapp; \c webapp Start building your table in this database by CREATE TABLE command. You can use Postgres docs to guide you with the commands.
For this demonstration, we are creating a student database that stores Name, Year and Branch. (Add more attributes if you want) CREATE TABLE student 
(name varchar(20), semester int, branch varchar(20)); \d student Now, we can start uploading some dummy data to the table via INSERT command INSERT INTO student VALUES
('Abel', 4, 'CE'), 
('John', 6, 'ME'), 
('Doe', 2, 'ETC'); Once we are done, adding the dummy data, we can view the Student table with the below command SELECT * FROM student; If you followed the steps till now, you would get the below student table! Step 2: Create a simple HTML Website Below is the Boilerplate HTML code for a simple website: <!DOCTYPE html>
<html lang='en'>
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width">
  <title> Student Management System </title>
</head>
<body>
  <h1> Student Management System </h1>
</body>
</html> Let's start adding the custom div blocks as per our needs: ...
<body>
  <h1> Student Management System </h1>
  <p> Here, are the student details as below: </p>
  <div id='students_list'></div>
... students_list div block is for showing the list of students that have been registered to the database. We will be using Express JS to fetch the data from Postgres and showcase it in the block. Step 3: Connecting HTML to Postgres via Express JS Install the necessary libraries first in your Command Prompt or Terminal npm install express body-parser pg Let's start building the script.js file for connecting HTML and PostgreSQL. Firstly, we require importing the necessary libraries for handling requests and establishing a connection // Import required modules
const express = require('express');
const { Pool } = require('pg');
const path = require('path');
const bodyParser = require('body-parser'); express works as a backend service, for parsing requests from the HTML webapp
pg is a Postgres API for establishing the connection
path provides utilities for managing directory paths
body-parser is a middle-ware for extracting data from POST requests
(We will be understanding them in depth as we move along) Let's now create an express application connection and also, define the port at which the server will be listening to. // Connect and Create an Express Application
const app = express();
const port = 3000; // By default, its 3000, you can customize Establish a connection to Postgres by creating an instance of the Pool object. Add the necessary values to match your Postgres setup. // Create a Postgres Connection
const pool = new Pool({
  user: 'postgres',
  host: 'localhost',
  database: 'webapp',
  password: 'password', // Change to your password
  port: 5432, // Default Port
}); Add functionalities to register static files via express.static() middleware. It specifies the root directory from which to serve static files app.use(express.static(path.join(''))); Now, we have to parse HTML requests sent from the app. In simple words, it's a middleware used to recieve data from users, such as forms or uploads app.use(bodyParser.urlencoded({ extended: false })); (Don't add the above line if you are not planning to take input from users. We will be adding a registeration form in the next blog and that's why we require body-parser) Set up a Route handler for the root URL ('/'). So that, when a GET request is made to the root URL, the server responds by sending the "index.html" file located in the same directory // Setup Route handler
app.get('/', (req, res) => {
  res.sendFile(path.join(__dirname, '', 'index.html'));
}); Now, comes the main part! We will now be setting up a route handler for '/students' URL with the HTTP GET method. This handler retrieves student data (from query) from the Postgres Database. // Route handler for GET student data
app.get('/students', (req, res) => {
  const query = 'SELECT * FROM student;';

  pool.query(query, (error, result) => {
    if (error) {
      console.error('Error occurred:', error);
      res.status(500).send('An error occurred while retrieving data from the database.');
    } else {
      const students = result.rows;
      res.json(students);
    }
  });
}); (Make sure the brackets are closed properly) Now, let's specify the line that listens to the server and when the time is due, it responds with its requests. As the below command listens, it logs a message to console. // Listening to Requests
app.listen(port, () => {
  console.log(`Server listening on port ${port}`);
}); (Good for debugging purposes) Done! script.js is finally complete. Let's make the changes in the index.html file for showcasing the necessary details. ...
  <div id='students_list'></div>
  <script>
  // Fetch data via requests
  fetch('/students')
    .then(response => response.json())
    .then(data => {
    const studentList = data.map(
      student => `<li> About ${student.name} : ${student.branch} - ${student.semester}th Sem</li>`
    ).join('');
    document.getElementById('students_list').innerHTML = `<ul>${studentList}</ul>`;
  })
    .catch(error => console.error('Error occurred:', error));
  </script>
... Run the Website Open Terminal and go to the directory where index.html and script.js is stored and run the following command: node script.js If everything works all right, it should display the content "Server listening on port 3000" Now, you need to go to http://localhost:3000/ where you can see a simple HTML website showcasing the data you had entered! Voila! That's it! Now, use your creativity and knowledge to explore these web development concepts and create more interesting websites! I will also be adding another blog on how to create a registration system and how to design it, which will be coming soon. Follow for more and stay tuned! Until then, Keep Coding! Get Ready, Future Web Developers! Let's create a simple HTML website that connects to a Postgres Database. For this example, we will be using JavaScript (Node JS, and Express JS) for its middleware functionalities. Whether you want to showcase your portfolio, run a blog, or complete a due mini project on web development, web development is a skill that's still in demand. The Learning Path Ahead We'll dive into the process of building a simple HTML website from scratch. We'll explore how to integrate a Postgres database, using JavaScript as middleware to handle API requests. To spice things up, we can also use Bootstrap5 to design the webpage! But that will be covered in a different blog. Technologies Used: HTML5 Postgres (Database) Express JS (Backend) HTML5 Postgres (Database) Express JS (Backend) Prerequisites Make sure Postgres is downloaded and ready to use. Also, download Node JS for installing npm packages like Express JS, Body Parser and Postgres APIs.
Download Postgres here Download NodeJS here here here Step 1: Setup Postgres Database Create a new Postgres Database either using psql , which is the CLI for running SQL commands or a graphical user interface like pgAdmin (which comes pre-installed). For this demonstration, we will be using psql for creating the database. psql psql Open psql and enter the credentials to get started. psql Create a database called webapp and connect to it! (You can use any name you want for your project!) webapp (You can use any name you want for your project!) CREATE database webapp; CREATE database webapp; \c webapp \c webapp Start building your table in this database by CREATE TABLE command. You can use Postgres docs to guide you with the commands.
For this demonstration, we are creating a student database that stores Name , Year and Branch . (Add more attributes if you want) CREATE TABLE student Name Year Branch (Add more attributes if you want) CREATE TABLE student 
(name varchar(20), semester int, branch varchar(20)); CREATE TABLE student 
(name varchar(20), semester int, branch varchar(20)); \d student \d student Now, we can start uploading some dummy data to the table via INSERT command INSERT INTO student VALUES
('Abel', 4, 'CE'), 
('John', 6, 'ME'), 
('Doe', 2, 'ETC'); INSERT INTO student VALUES
('Abel', 4, 'CE'), 
('John', 6, 'ME'), 
('Doe', 2, 'ETC'); Once we are done, adding the dummy data, we can view the Student table with the below command Student SELECT * FROM student; SELECT * FROM student; If you followed the steps till now, you would get the below student table! student Step 2: Create a simple HTML Website Below is the Boilerplate HTML code for a simple website: <!DOCTYPE html>
<html lang='en'>
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width">
  <title> Student Management System </title>
</head>
<body>
  <h1> Student Management System </h1>
</body>
</html> <!DOCTYPE html>
<html lang='en'>
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width">
  <title> Student Management System </title>
</head>
<body>
  <h1> Student Management System </h1>
</body>
</html> Let's start adding the custom div blocks as per our needs: ...
<body>
  <h1> Student Management System </h1>
  <p> Here, are the student details as below: </p>
  <div id='students_list'></div>
... ...
<body>
  <h1> Student Management System </h1>
  <p> Here, are the student details as below: </p>
  <div id='students_list'></div>
... students_list div block is for showing the list of students that have been registered to the database. We will be using Express JS to fetch the data from Postgres and showcase it in the block. students_list Step 3: Connecting HTML to Postgres via Express JS Install the necessary libraries first in your Command Prompt or Terminal Command Prompt npm install express body-parser pg npm install express body-parser pg Let's start building the script.js file for connecting HTML and PostgreSQL. Firstly, we require importing the necessary libraries for handling requests and establishing a connection script.js // Import required modules
const express = require('express');
const { Pool } = require('pg');
const path = require('path');
const bodyParser = require('body-parser'); // Import required modules
const express = require('express');
const { Pool } = require('pg');
const path = require('path');
const bodyParser = require('body-parser'); express works as a backend service, for parsing requests from the HTML webapp pg is a Postgres API for establishing the connection path provides utilities for managing directory paths body-parser is a middle-ware for extracting data from POST requests (We will be understanding them in depth as we move along) express pg path body-parser (We will be understanding them in depth as we move along) Let's now create an express application connection and also, define the port at which the server will be listening to. // Connect and Create an Express Application
const app = express();
const port = 3000; // By default, its 3000, you can customize // Connect and Create an Express Application
const app = express();
const port = 3000; // By default, its 3000, you can customize Establish a connection to Postgres by creating an instance of the Pool object. Add the necessary values to match your Postgres setup. Pool // Create a Postgres Connection
const pool = new Pool({
  user: 'postgres',
  host: 'localhost',
  database: 'webapp',
  password: 'password', // Change to your password
  port: 5432, // Default Port
}); // Create a Postgres Connection
const pool = new Pool({
  user: 'postgres',
  host: 'localhost',
  database: 'webapp',
  password: 'password', // Change to your password
  port: 5432, // Default Port
}); Add functionalities to register static files via express.static() middleware. It specifies the root directory from which to serve static files express.static() app.use(express.static(path.join(''))); app.use(express.static(path.join(''))); Now, we have to parse HTML requests sent from the app. In simple words, it's a middleware used to recieve data from users, such as forms or uploads app.use(bodyParser.urlencoded({ extended: false })); app.use(bodyParser.urlencoded({ extended: false })); (Don't add the above line if you are not planning to take input from users. We will be adding a registeration form in the next blog and that's why we require body-parser) (Don't add the above line if you are not planning to take input from users. We will be adding a registeration form in the next blog and that's why we require body-parser) Set up a Route handler for the root URL ('/'). So that, when a GET request is made to the root URL, the server responds by sending the "index.html" file located in the same directory // Setup Route handler
app.get('/', (req, res) => {
  res.sendFile(path.join(__dirname, '', 'index.html'));
}); // Setup Route handler
app.get('/', (req, res) => {
  res.sendFile(path.join(__dirname, '', 'index.html'));
}); Now, comes the main part! We will now be setting up a route handler for '/students' URL with the HTTP GET method. This handler retrieves student data (from query) from the Postgres Database. // Route handler for GET student data
app.get('/students', (req, res) => {
  const query = 'SELECT * FROM student;';

  pool.query(query, (error, result) => {
    if (error) {
      console.error('Error occurred:', error);
      res.status(500).send('An error occurred while retrieving data from the database.');
    } else {
      const students = result.rows;
      res.json(students);
    }
  });
}); // Route handler for GET student data
app.get('/students', (req, res) => {
  const query = 'SELECT * FROM student;';

  pool.query(query, (error, result) => {
    if (error) {
      console.error('Error occurred:', error);
      res.status(500).send('An error occurred while retrieving data from the database.');
    } else {
      const students = result.rows;
      res.json(students);
    }
  });
}); (Make sure the brackets are closed properly) (Make sure the brackets are closed properly) Now, let's specify the line that listens to the server and when the time is due, it responds with its requests. As the below command listens, it logs a message to console. // Listening to Requests
app.listen(port, () => {
  console.log(`Server listening on port ${port}`);
}); // Listening to Requests
app.listen(port, () => {
  console.log(`Server listening on port ${port}`);
}); (Good for debugging purposes) (Good for debugging purposes) Done! script.js is finally complete. Let's make the changes in the index.html file for showcasing the necessary details. script.js index.html ...
  <div id='students_list'></div>
  <script>
  // Fetch data via requests
  fetch('/students')
    .then(response => response.json())
    .then(data => {
    const studentList = data.map(
      student => `<li> About ${student.name} : ${student.branch} - ${student.semester}th Sem</li>`
    ).join('');
    document.getElementById('students_list').innerHTML = `<ul>${studentList}</ul>`;
  })
    .catch(error => console.error('Error occurred:', error));
  </script>
... ...
  <div id='students_list'></div>
  <script>
  // Fetch data via requests
  fetch('/students')
    .then(response => response.json())
    .then(data => {
    const studentList = data.map(
      student => `<li> About ${student.name} : ${student.branch} - ${student.semester}th Sem</li>`
    ).join('');
    document.getElementById('students_list').innerHTML = `<ul>${studentList}</ul>`;
  })
    .catch(error => console.error('Error occurred:', error));
  </script>
... Run the Website Open Terminal and go to the directory where index.html and script.js is stored and run the following command: index.html script.js node script.js node script.js If everything works all right, it should display the content "Server listening on port 3000" Now, you need to go to http://localhost:3000/ where you can see a simple HTML website showcasing the data you had entered! http://localhost:3000/ Voila! That's it! Voila! That's it! Now, use your creativity and knowledge to explore these web development concepts and create more interesting websites! I will also be adding another blog on how to create a registration system and how to design it, which will be coming soon. Follow for more and stay tuned! Until then, Keep Coding!

Build a Simple HTML Website with Postgres Database Connectivity

Postgres ডাটাবেস সংযোগ সহ একটি সাধারণ HTML ওয়েবসাইট তৈরি করুন

Erstellen Sie eine einfache HTML-Website mit Postgres-Datenbankkonnektivität

Cree un sitio web HTML simple con conectividad de base de datos Postgres

Créez un site Web HTML simple avec la connectivité de la base de données Postgres

Postgres डेटाबेस कनेक्टिविटी के साथ एक सरल HTML वेबसाइट बनाएं

Postgres データベース接続を備えたシンプルな HTML ウェブサイトを構築する

Postgres 데이터베이스 연결을 사용하여 간단한 HTML 웹사이트 구축

Crie um site HTML simples com conectividade de banco de dados Postgres

Создайте простой HTML-сайт с возможностью подключения к базе данных Postgres

Postgres Veritabanı Bağlantısı ile Basit Bir HTML Web Sitesi Oluşturun

Xây dựng một trang web HTML đơn giản với kết nối cơ sở dữ liệu Postgres

使用 Postgres 数据库连接构建一个简单的 HTML 网站

Fimple

fimple.co.uk

51-200 employees

Since 2022

COMPANY RANKING

FIMPLE

EVERGREEN INDEX #4030

Fimple WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!

Fimple

fimple.co.uk

51-200 employees

Since 2022

COMPANY RANKING

FIMPLE

EVERGREEN INDEX #4030

RELATED COMPANIESRANK

STORIES ABOUT FIMPLE

Fimple WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!